Add m-esr52 at 52.6.0

1 files changed, 2537 insertions, 0 deletions

diff --git a/layout/style/nsStyleSet.cpp b/layout/style/nsStyleSet.cpp
new file mode 100644
index 000000000..414eee4d4
--- /dev/null
+++ b/layout/style/nsStyleSet.cpp
@@ -0,0 +1,2537 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+/*
+ * the container for the style sheets that apply to a presentation, and
+ * the internal API that the style system exposes for creating (and
+ * potentially re-creating) style contexts
+ */
+
+#include "nsStyleSet.h"
+
+#include "mozilla/ArrayUtils.h"
+#include "mozilla/StyleSheetInlines.h"
+#include "mozilla/EffectCompositor.h"
+#include "mozilla/EnumeratedRange.h"
+#include "mozilla/EventStates.h"
+#include "mozilla/MemoryReporting.h"
+#include "mozilla/RuleProcessorCache.h"
+#include "mozilla/StyleSheetInlines.h"
+#include "nsIDocumentInlines.h"
+#include "nsRuleWalker.h"
+#include "nsStyleContext.h"
+#include "mozilla/css/StyleRule.h"
+#include "nsCSSAnonBoxes.h"
+#include "nsCSSPseudoElements.h"
+#include "nsCSSRuleProcessor.h"
+#include "nsDataHashtable.h"
+#include "nsIContent.h"
+#include "nsRuleData.h"
+#include "nsRuleProcessorData.h"
+#include "nsAnimationManager.h"
+#include "nsStyleSheetService.h"
+#include "mozilla/dom/Element.h"
+#include "GeckoProfiler.h"
+#include "nsHTMLCSSStyleSheet.h"
+#include "nsHTMLStyleSheet.h"
+#include "SVGAttrAnimationRuleProcessor.h"
+#include "nsCSSRules.h"
+#include "nsPrintfCString.h"
+#include "nsIFrame.h"
+#include "mozilla/RestyleManagerHandle.h"
+#include "mozilla/RestyleManagerHandleInlines.h"
+#include "nsQueryObject.h"
+
+#include <inttypes.h>
+
+using namespace mozilla;
+using namespace mozilla::dom;
+
+NS_IMPL_ISUPPORTS(nsEmptyStyleRule, nsIStyleRule)
+
+/* virtual */ void
+nsEmptyStyleRule::MapRuleInfoInto(nsRuleData* aRuleData)
+{
+}
+
+/* virtual */ bool
+nsEmptyStyleRule::MightMapInheritedStyleData()
+{
+  return false;
+}
+
+/* virtual */ bool
+nsEmptyStyleRule::GetDiscretelyAnimatedCSSValue(nsCSSPropertyID aProperty,
+                                                nsCSSValue* aValue)
+{
+  MOZ_ASSERT(false, "GetDiscretelyAnimatedCSSValue is not implemented yet");
+  return false;
+}
+
+#ifdef DEBUG
+/* virtual */ void
+nsEmptyStyleRule::List(FILE* out, int32_t aIndent) const
+{
+  nsAutoCString indentStr;
+  for (int32_t index = aIndent; --index >= 0; ) {
+    indentStr.AppendLiteral("  ");
+  }
+  fprintf_stderr(out, "%s[empty style rule] {}\n", indentStr.get());
+}
+#endif
+
+NS_IMPL_ISUPPORTS(nsInitialStyleRule, nsIStyleRule)
+
+/* virtual */ void
+nsInitialStyleRule::MapRuleInfoInto(nsRuleData* aRuleData)
+{
+  // Iterate over the property groups
+  for (nsStyleStructID sid = nsStyleStructID(0);
+       sid < nsStyleStructID_Length; sid = nsStyleStructID(sid + 1)) {
+    if (aRuleData->mSIDs & (1 << sid)) {
+      // Iterate over nsCSSValues within the property group
+      nsCSSValue * const value_start =
+        aRuleData->mValueStorage + aRuleData->mValueOffsets[sid];
+      for (nsCSSValue *value = value_start,
+           *value_end = value + nsCSSProps::PropertyCountInStruct(sid);
+           value != value_end; ++value) {
+        // If MathML is disabled take care not to set MathML properties (or we
+        // will trigger assertions in nsRuleNode)
+        if (sid == eStyleStruct_Font &&
+            !aRuleData->mPresContext->Document()->GetMathMLEnabled()) {
+          size_t index = value - value_start;
+          if (index == nsCSSProps::PropertyIndexInStruct(
+                          eCSSProperty_script_level) ||
+              index == nsCSSProps::PropertyIndexInStruct(
+                          eCSSProperty_script_size_multiplier) ||
+              index == nsCSSProps::PropertyIndexInStruct(
+                          eCSSProperty_script_min_size) ||
+              index == nsCSSProps::PropertyIndexInStruct(
+                          eCSSProperty_math_variant) ||
+              index == nsCSSProps::PropertyIndexInStruct(
+                          eCSSProperty_math_display)) {
+            continue;
+          }
+        }
+        if (value->GetUnit() == eCSSUnit_Null) {
+          value->SetInitialValue();
+        }
+      }
+    }
+  }
+}
+
+/* virtual */ bool
+nsInitialStyleRule::MightMapInheritedStyleData()
+{
+  return true;
+}
+
+/* virtual */ bool
+nsInitialStyleRule::GetDiscretelyAnimatedCSSValue(nsCSSPropertyID aProperty,
+                                                  nsCSSValue* aValue)
+{
+  MOZ_ASSERT(false, "GetDiscretelyAnimatedCSSValue is not implemented yet");
+  return false;
+}
+
+#ifdef DEBUG
+/* virtual */ void
+nsInitialStyleRule::List(FILE* out, int32_t aIndent) const
+{
+  nsAutoCString indentStr;
+  for (int32_t index = aIndent; --index >= 0; ) {
+    indentStr.AppendLiteral("  ");
+  }
+  fprintf_stderr(out, "%s[initial style rule] {}\n", indentStr.get());
+}
+#endif
+
+NS_IMPL_ISUPPORTS(nsDisableTextZoomStyleRule, nsIStyleRule)
+
+/* virtual */ void
+nsDisableTextZoomStyleRule::MapRuleInfoInto(nsRuleData* aRuleData)
+{
+  if (!(aRuleData->mSIDs & NS_STYLE_INHERIT_BIT(Font)))
+    return;
+
+  nsCSSValue* value = aRuleData->ValueForTextZoom();
+  if (value->GetUnit() == eCSSUnit_Null)
+    value->SetNoneValue();
+}
+
+/* virtual */ bool
+nsDisableTextZoomStyleRule::MightMapInheritedStyleData()
+{
+  return true;
+}
+
+/* virtual */ bool
+nsDisableTextZoomStyleRule::
+GetDiscretelyAnimatedCSSValue(nsCSSPropertyID aProperty, nsCSSValue* aValue)
+{
+  MOZ_ASSERT(false, "GetDiscretelyAnimatedCSSValue is not implemented yet");
+  return false;
+}
+
+#ifdef DEBUG
+/* virtual */ void
+nsDisableTextZoomStyleRule::List(FILE* out, int32_t aIndent) const
+{
+  nsAutoCString indentStr;
+  for (int32_t index = aIndent; --index >= 0; ) {
+    indentStr.AppendLiteral("  ");
+  }
+  fprintf_stderr(out, "%s[disable text zoom style rule] {}\n", indentStr.get());
+}
+#endif
+
+static const SheetType gCSSSheetTypes[] = {
+  // From lowest to highest in cascading order.
+  SheetType::Agent,
+  SheetType::User,
+  SheetType::Doc,
+  SheetType::ScopedDoc,
+  SheetType::Override
+};
+
+/* static */ bool
+nsStyleSet::IsCSSSheetType(SheetType aSheetType)
+{
+  for (SheetType type : gCSSSheetTypes) {
+    if (type == aSheetType) {
+      return true;
+    }
+  }
+  return false;
+}
+
+nsStyleSet::nsStyleSet()
+  : mRuleTree(nullptr),
+    mBatching(0),
+    mInShutdown(false),
+    mInGC(false),
+    mAuthorStyleDisabled(false),
+    mInReconstruct(false),
+    mInitFontFeatureValuesLookup(true),
+    mNeedsRestyleAfterEnsureUniqueInner(false),
+    mDirty(0),
+    mRootStyleContextCount(0),
+#ifdef DEBUG
+    mOldRootNode(nullptr),
+#endif
+    mUnusedRuleNodeCount(0)
+{
+}
+
+nsStyleSet::~nsStyleSet()
+{
+  for (SheetType type : gCSSSheetTypes) {
+    for (CSSStyleSheet* sheet : mSheets[type]) {
+      sheet->DropStyleSet(this);
+    }
+  }
+
+  // drop reference to cached rule processors
+  nsCSSRuleProcessor* rp;
+  rp = static_cast<nsCSSRuleProcessor*>(mRuleProcessors[SheetType::Agent].get());
+  if (rp) {
+    MOZ_ASSERT(rp->IsShared());
+    rp->ReleaseStyleSetRef();
+  }
+  rp = static_cast<nsCSSRuleProcessor*>(mRuleProcessors[SheetType::User].get());
+  if (rp) {
+    MOZ_ASSERT(rp->IsShared());
+    rp->ReleaseStyleSetRef();
+  }
+}
+
+size_t
+nsStyleSet::SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const
+{
+  size_t n = aMallocSizeOf(this);
+
+  for (SheetType type : MakeEnumeratedRange(SheetType::Count)) {
+    if (mRuleProcessors[type]) {
+      bool shared = false;
+      if (type == SheetType::Agent || type == SheetType::User) {
+        // The only two origins we consider caching rule processors for.
+        nsCSSRuleProcessor* rp =
+          static_cast<nsCSSRuleProcessor*>(mRuleProcessors[type].get());
+        shared = rp->IsShared();
+      }
+      if (!shared) {
+        n += mRuleProcessors[type]->SizeOfIncludingThis(aMallocSizeOf);
+      }
+    }
+    // We don't own the sheets (either the nsLayoutStyleSheetCache singleton
+    // or our document owns them).
+    n += mSheets[type].ShallowSizeOfExcludingThis(aMallocSizeOf);
+  }
+
+  for (uint32_t i = 0; i < mScopedDocSheetRuleProcessors.Length(); i++) {
+    n += mScopedDocSheetRuleProcessors[i]->SizeOfIncludingThis(aMallocSizeOf);
+  }
+  n += mScopedDocSheetRuleProcessors.ShallowSizeOfExcludingThis(aMallocSizeOf);
+
+  return n;
+}
+
+void
+nsStyleSet::Init(nsPresContext *aPresContext)
+{
+  mFirstLineRule = new nsEmptyStyleRule;
+  mFirstLetterRule = new nsEmptyStyleRule;
+  mPlaceholderRule = new nsEmptyStyleRule;
+  mDisableTextZoomStyleRule = new nsDisableTextZoomStyleRule;
+
+  mRuleTree = nsRuleNode::CreateRootNode(aPresContext);
+
+  // Make an explicit GatherRuleProcessors call for the levels that
+  // don't have style sheets.  The other levels will have their calls
+  // triggered by DirtyRuleProcessors.
+  GatherRuleProcessors(SheetType::PresHint);
+  GatherRuleProcessors(SheetType::SVGAttrAnimation);
+  GatherRuleProcessors(SheetType::StyleAttr);
+  GatherRuleProcessors(SheetType::Animation);
+  GatherRuleProcessors(SheetType::Transition);
+}
+
+nsresult
+nsStyleSet::BeginReconstruct()
+{
+  NS_ASSERTION(!mInReconstruct, "Unmatched begin/end?");
+  NS_ASSERTION(mRuleTree, "Reconstructing before first construction?");
+  mInReconstruct = true;
+
+  // Clear any ArenaRefPtr-managed style contexts, as we don't want them
+  // held on to after the rule tree has been reconstructed.
+  PresContext()->PresShell()->ClearArenaRefPtrs(eArenaObjectID_nsStyleContext);
+
+#ifdef DEBUG
+  MOZ_ASSERT(!mOldRootNode);
+  mOldRootNode = mRuleTree;
+#endif
+
+  // Create a new rule tree root, dropping the reference to our old rule tree.
+  // After reconstruction, we will re-enable GC, and allow everything to be
+  // collected.
+  mRuleTree = nsRuleNode::CreateRootNode(mRuleTree->PresContext());
+
+  return NS_OK;
+}
+
+void
+nsStyleSet::EndReconstruct()
+{
+  NS_ASSERTION(mInReconstruct, "Unmatched begin/end?");
+  mInReconstruct = false;
+  GCRuleTrees();
+}
+
+typedef nsDataHashtable<nsPtrHashKey<nsINode>, uint32_t> ScopeDepthCache;
+
+// Returns the depth of a style scope element, with 1 being the depth of
+// a style scope element that has no ancestor style scope elements.  The
+// depth does not count intervening non-scope elements.
+static uint32_t
+GetScopeDepth(nsINode* aScopeElement, ScopeDepthCache& aCache)
+{
+  nsINode* parent = aScopeElement->GetParent();
+  if (!parent || !parent->IsElementInStyleScope()) {
+    return 1;
+  }
+
+  uint32_t depth = aCache.Get(aScopeElement);
+  if (!depth) {
+    for (nsINode* n = parent; n; n = n->GetParent()) {
+      if (n->IsScopedStyleRoot()) {
+        depth = GetScopeDepth(n, aCache) + 1;
+        aCache.Put(aScopeElement, depth);
+        break;
+      }
+    }
+  }
+  return depth;
+}
+
+struct ScopedSheetOrder
+{
+  CSSStyleSheet* mSheet;
+  uint32_t mDepth;
+  uint32_t mOrder;
+
+  bool operator==(const ScopedSheetOrder& aRHS) const
+  {
+    return mDepth == aRHS.mDepth &&
+           mOrder == aRHS.mOrder;
+  }
+
+  bool operator<(const ScopedSheetOrder& aRHS) const
+  {
+    if (mDepth != aRHS.mDepth) {
+      return mDepth < aRHS.mDepth;
+    }
+    return mOrder < aRHS.mOrder;
+  }
+};
+
+// Sorts aSheets such that style sheets for ancestor scopes come
+// before those for descendant scopes, and with sheets for a single
+// scope in document order.
+static void
+SortStyleSheetsByScope(nsTArray<CSSStyleSheet*>& aSheets)
+{
+  uint32_t n = aSheets.Length();
+  if (n == 1) {
+    return;
+  }
+
+  ScopeDepthCache cache;
+
+  nsTArray<ScopedSheetOrder> sheets;
+  sheets.SetLength(n);
+
+  // For each sheet, record the depth of its scope element and its original
+  // document order.
+  for (uint32_t i = 0; i < n; i++) {
+    sheets[i].mSheet = aSheets[i];
+    sheets[i].mDepth = GetScopeDepth(aSheets[i]->GetScopeElement(), cache);
+    sheets[i].mOrder = i;
+  }
+
+  // Sort by depth first, then document order.
+  sheets.Sort();
+
+  for (uint32_t i = 0; i < n; i++) {
+    aSheets[i] = sheets[i].mSheet;
+  }
+}
+
+nsresult
+nsStyleSet::GatherRuleProcessors(SheetType aType)
+{
+  NS_ENSURE_FALSE(mInShutdown, NS_ERROR_FAILURE);
+
+  // We might be in GatherRuleProcessors because we are dropping a sheet,
+  // resulting in an nsCSSSelector being destroyed.  Tell the
+  // RestyleManager for each document we're used in so that they can
+  // drop any nsCSSSelector pointers (used for eRestyle_SomeDescendants)
+  // in their mPendingRestyles.
+  if (IsCSSSheetType(aType)) {
+    ClearSelectors();
+  }
+  nsCOMPtr<nsIStyleRuleProcessor> oldRuleProcessor(mRuleProcessors[aType]);
+  nsTArray<nsCOMPtr<nsIStyleRuleProcessor>> oldScopedDocRuleProcessors;
+  if (aType == SheetType::Agent || aType == SheetType::User) {
+    // drop reference to cached rule processor
+    nsCSSRuleProcessor* rp =
+      static_cast<nsCSSRuleProcessor*>(mRuleProcessors[aType].get());
+    if (rp) {
+      MOZ_ASSERT(rp->IsShared());
+      rp->ReleaseStyleSetRef();
+    }
+  }
+  mRuleProcessors[aType] = nullptr;
+  if (aType == SheetType::ScopedDoc) {
+    for (uint32_t i = 0; i < mScopedDocSheetRuleProcessors.Length(); i++) {
+      nsIStyleRuleProcessor* processor = mScopedDocSheetRuleProcessors[i].get();
+      Element* scope =
+        static_cast<nsCSSRuleProcessor*>(processor)->GetScopeElement();
+      scope->ClearIsScopedStyleRoot();
+    }
+
+    // Clear mScopedDocSheetRuleProcessors, but save it.
+    oldScopedDocRuleProcessors.SwapElements(mScopedDocSheetRuleProcessors);
+  }
+  if (mAuthorStyleDisabled && (aType == SheetType::Doc ||
+                               aType == SheetType::ScopedDoc ||
+                               aType == SheetType::StyleAttr)) {
+    // Don't regather if this level is disabled.  Note that we gather
+    // preshint sheets no matter what, but then skip them for some
+    // elements later if mAuthorStyleDisabled.
+    return NS_OK;
+  }
+  switch (aType) {
+    // levels that do not contain CSS style sheets
+    case SheetType::Animation:
+      MOZ_ASSERT(mSheets[aType].IsEmpty());
+      mRuleProcessors[aType] = PresContext()->EffectCompositor()->
+        RuleProcessor(EffectCompositor::CascadeLevel::Animations);
+      return NS_OK;
+    case SheetType::Transition:
+      MOZ_ASSERT(mSheets[aType].IsEmpty());
+      mRuleProcessors[aType] = PresContext()->EffectCompositor()->
+        RuleProcessor(EffectCompositor::CascadeLevel::Transitions);
+      return NS_OK;
+    case SheetType::StyleAttr:
+      MOZ_ASSERT(mSheets[aType].IsEmpty());
+      mRuleProcessors[aType] = PresContext()->Document()->GetInlineStyleSheet();
+      return NS_OK;
+    case SheetType::PresHint:
+      MOZ_ASSERT(mSheets[aType].IsEmpty());
+      mRuleProcessors[aType] =
+        PresContext()->Document()->GetAttributeStyleSheet();
+      return NS_OK;
+    case SheetType::SVGAttrAnimation:
+      MOZ_ASSERT(mSheets[aType].IsEmpty());
+      mRuleProcessors[aType] =
+        PresContext()->Document()->GetSVGAttrAnimationRuleProcessor();
+      return NS_OK;
+    default:
+      // keep going
+      break;
+  }
+  MOZ_ASSERT(IsCSSSheetType(aType));
+  if (aType == SheetType::ScopedDoc) {
+    // Create a rule processor for each scope.
+    uint32_t count = mSheets[SheetType::ScopedDoc].Length();
+    if (count) {
+      // Gather the scoped style sheets into an array as
+      // CSSStyleSheets, and mark all of their scope elements
+      // as scoped style roots.
+      nsTArray<CSSStyleSheet*> sheets(count);
+      for (CSSStyleSheet* sheet : mSheets[SheetType::ScopedDoc]) {
+        sheets.AppendElement(sheet);
+
+        Element* scope = sheet->GetScopeElement();
+        scope->SetIsScopedStyleRoot();
+      }
+
+      // Sort the scoped style sheets so that those for the same scope are
+      // adjacent and that ancestor scopes come before descendent scopes.
+      SortStyleSheetsByScope(sheets);
+
+      // Put the old scoped rule processors in a hashtable so that we
+      // can retrieve them efficiently, even in edge cases like the
+      // simultaneous removal and addition of a large number of elements
+      // with scoped sheets.
+      nsDataHashtable<nsPtrHashKey<Element>,
+                      nsCSSRuleProcessor*> oldScopedRuleProcessorHash;
+      for (size_t i = oldScopedDocRuleProcessors.Length(); i-- != 0; ) {
+        nsCSSRuleProcessor* oldRP =
+          static_cast<nsCSSRuleProcessor*>(oldScopedDocRuleProcessors[i].get());
+        Element* scope = oldRP->GetScopeElement();
+        MOZ_ASSERT(!oldScopedRuleProcessorHash.Get(scope),
+                   "duplicate rule processors for same scope element?");
+        oldScopedRuleProcessorHash.Put(scope, oldRP);
+      }
+
+      uint32_t start = 0, end;
+      do {
+        // Find the range of style sheets with the same scope.
+        Element* scope = sheets[start]->GetScopeElement();
+        end = start + 1;
+        while (end < count && sheets[end]->GetScopeElement() == scope) {
+          end++;
+        }
+
+        scope->SetIsScopedStyleRoot();
+
+        // Create a rule processor for the scope.
+        nsTArray<RefPtr<CSSStyleSheet>> sheetsForScope;
+        sheetsForScope.AppendElements(sheets.Elements() + start, end - start);
+        nsCSSRuleProcessor* oldRP = oldScopedRuleProcessorHash.Get(scope);
+        mScopedDocSheetRuleProcessors.AppendElement
+          (new nsCSSRuleProcessor(Move(sheetsForScope), aType, scope, oldRP));
+
+        start = end;
+      } while (start < count);
+    }
+    return NS_OK;
+  }
+  if (!mSheets[aType].IsEmpty()) {
+    switch (aType) {
+      case SheetType::Agent:
+      case SheetType::User: {
+        // levels containing non-scoped CSS style sheets whose rule processors
+        // we want to re-use
+        nsTArray<CSSStyleSheet*> sheets(mSheets[aType].Length());
+        for (CSSStyleSheet* sheet : mSheets[aType]) {
+          sheets.AppendElement(sheet);
+        }
+        nsCSSRuleProcessor* rp =
+          RuleProcessorCache::GetRuleProcessor(sheets, PresContext());
+        if (!rp) {
+          rp = new nsCSSRuleProcessor(mSheets[aType], aType, nullptr,
+                                      static_cast<nsCSSRuleProcessor*>(
+                                       oldRuleProcessor.get()),
+                                      true /* aIsShared */);
+          nsTArray<css::DocumentRule*> documentRules;
+          nsDocumentRuleResultCacheKey cacheKey;
+          rp->TakeDocumentRulesAndCacheKey(PresContext(),
+                                           documentRules, cacheKey);
+          RuleProcessorCache::PutRuleProcessor(sheets,
+                                               Move(documentRules),
+                                               cacheKey, rp);
+        }
+        mRuleProcessors[aType] = rp;
+        rp->AddStyleSetRef();
+        break;
+      }
+      case SheetType::Doc:
+      case SheetType::Override: {
+        // levels containing non-scoped CSS stylesheets whose rule processors
+        // we don't want to re-use
+        mRuleProcessors[aType] =
+          new nsCSSRuleProcessor(mSheets[aType], aType, nullptr,
+                                 static_cast<nsCSSRuleProcessor*>(
+                                   oldRuleProcessor.get()));
+      } break;
+
+      default:
+        MOZ_ASSERT_UNREACHABLE("non-CSS sheet types should be handled above");
+        break;
+    }
+  }
+
+  return NS_OK;
+}
+
+nsresult
+nsStyleSet::AppendStyleSheet(SheetType aType, CSSStyleSheet* aSheet)
+{
+  NS_PRECONDITION(aSheet, "null arg");
+  NS_ASSERTION(aSheet->IsApplicable(),
+               "Inapplicable sheet being placed in style set");
+  bool present = mSheets[aType].RemoveElement(aSheet);
+  mSheets[aType].AppendElement(aSheet);
+
+  if (!present && IsCSSSheetType(aType)) {
+    aSheet->AddStyleSet(this);
+  }
+
+  return DirtyRuleProcessors(aType);
+}
+
+nsresult
+nsStyleSet::PrependStyleSheet(SheetType aType, CSSStyleSheet* aSheet)
+{
+  NS_PRECONDITION(aSheet, "null arg");
+  NS_ASSERTION(aSheet->IsApplicable(),
+               "Inapplicable sheet being placed in style set");
+  bool present = mSheets[aType].RemoveElement(aSheet);
+  mSheets[aType].InsertElementAt(0, aSheet);
+
+  if (!present && IsCSSSheetType(aType)) {
+    aSheet->AddStyleSet(this);
+  }
+
+  return DirtyRuleProcessors(aType);
+}
+
+nsresult
+nsStyleSet::RemoveStyleSheet(SheetType aType, CSSStyleSheet* aSheet)
+{
+  NS_PRECONDITION(aSheet, "null arg");
+  NS_ASSERTION(aSheet->IsComplete(),
+               "Incomplete sheet being removed from style set");
+  if (mSheets[aType].RemoveElement(aSheet)) {
+    if (IsCSSSheetType(aType)) {
+      aSheet->DropStyleSet(this);
+    }
+  }
+
+  return DirtyRuleProcessors(aType);
+}
+
+nsresult
+nsStyleSet::ReplaceSheets(SheetType aType,
+                          const nsTArray<RefPtr<CSSStyleSheet>>& aNewSheets)
+{
+  bool cssSheetType = IsCSSSheetType(aType);
+  if (cssSheetType) {
+    for (CSSStyleSheet* sheet : mSheets[aType]) {
+      sheet->DropStyleSet(this);
+    }
+  }
+
+  mSheets[aType].Clear();
+  mSheets[aType].AppendElements(aNewSheets);
+
+  if (cssSheetType) {
+    for (CSSStyleSheet* sheet : mSheets[aType]) {
+      sheet->AddStyleSet(this);
+    }
+  }
+
+  return DirtyRuleProcessors(aType);
+}
+
+nsresult
+nsStyleSet::InsertStyleSheetBefore(SheetType aType, CSSStyleSheet* aNewSheet,
+                                   CSSStyleSheet* aReferenceSheet)
+{
+  NS_PRECONDITION(aNewSheet && aReferenceSheet, "null arg");
+  NS_ASSERTION(aNewSheet->IsApplicable(),
+               "Inapplicable sheet being placed in style set");
+
+  bool present = mSheets[aType].RemoveElement(aNewSheet);
+  int32_t idx = mSheets[aType].IndexOf(aReferenceSheet);
+  if (idx < 0)
+    return NS_ERROR_INVALID_ARG;
+
+  mSheets[aType].InsertElementAt(idx, aNewSheet);
+
+  if (!present && IsCSSSheetType(aType)) {
+    aNewSheet->AddStyleSet(this);
+  }
+
+  return DirtyRuleProcessors(aType);
+}
+
+static inline uint32_t
+DirtyBit(SheetType aType)
+{
+  return 1 << uint32_t(aType);
+}
+
+nsresult
+nsStyleSet::DirtyRuleProcessors(SheetType aType)
+{
+  if (!mBatching)
+    return GatherRuleProcessors(aType);
+
+  mDirty |= DirtyBit(aType);
+  return NS_OK;
+}
+
+bool
+nsStyleSet::GetAuthorStyleDisabled() const
+{
+  return mAuthorStyleDisabled;
+}
+
+nsresult
+nsStyleSet::SetAuthorStyleDisabled(bool aStyleDisabled)
+{
+  if (aStyleDisabled == !mAuthorStyleDisabled) {
+    mAuthorStyleDisabled = aStyleDisabled;
+    BeginUpdate();
+    mDirty |= DirtyBit(SheetType::Doc) |
+              DirtyBit(SheetType::ScopedDoc) |
+              DirtyBit(SheetType::StyleAttr);
+    return EndUpdate();
+  }
+  return NS_OK;
+}
+
+// -------- Doc Sheets
+
+nsresult
+nsStyleSet::AddDocStyleSheet(CSSStyleSheet* aSheet, nsIDocument* aDocument)
+{
+  NS_PRECONDITION(aSheet && aDocument, "null arg");
+  NS_ASSERTION(aSheet->IsApplicable(),
+               "Inapplicable sheet being placed in style set");
+
+  SheetType type = aSheet->GetScopeElement() ?
+                     SheetType::ScopedDoc :
+                     SheetType::Doc;
+  nsTArray<RefPtr<CSSStyleSheet>>& sheets = mSheets[type];
+
+  bool present = sheets.RemoveElement(aSheet);
+
+  size_t index = aDocument->FindDocStyleSheetInsertionPoint(sheets, aSheet);
+  sheets.InsertElementAt(index, aSheet);
+
+  if (!present) {
+    aSheet->AddStyleSet(this);
+  }
+
+  return DirtyRuleProcessors(type);
+}
+
+void
+nsStyleSet::AppendAllXBLStyleSheets(nsTArray<mozilla::CSSStyleSheet*>& aArray) const
+{
+  if (mBindingManager) {
+    // XXXheycam stylo: AppendAllSheets will need to be able to return either
+    // CSSStyleSheets or ServoStyleSheets, on request (and then here requesting
+    // CSSStyleSheets).
+    AutoTArray<StyleSheet*, 32> sheets;
+    mBindingManager->AppendAllSheets(sheets);
+    for (StyleSheet* handle : sheets) {
+      MOZ_ASSERT(handle->IsGecko(), "stylo: AppendAllSheets shouldn't give us "
+                                    "ServoStyleSheets yet");
+      aArray.AppendElement(handle->AsGecko());
+    }
+  }
+}
+
+nsresult
+nsStyleSet::RemoveDocStyleSheet(CSSStyleSheet* aSheet)
+{
+  bool isScoped = aSheet->GetScopeElement();
+  return RemoveStyleSheet(isScoped ? SheetType::ScopedDoc : SheetType::Doc,
+                          aSheet);
+}
+
+// Batching
+void
+nsStyleSet::BeginUpdate()
+{
+  ++mBatching;
+}
+
+nsresult
+nsStyleSet::EndUpdate()
+{
+  NS_ASSERTION(mBatching > 0, "Unbalanced EndUpdate");
+  if (--mBatching) {
+    // We're not completely done yet.
+    return NS_OK;
+  }
+
+  for (SheetType type : MakeEnumeratedRange(SheetType::Count)) {
+    if (mDirty & DirtyBit(type)) {
+      nsresult rv = GatherRuleProcessors(type);
+      NS_ENSURE_SUCCESS(rv, rv);
+    }
+  }
+
+  mDirty = 0;
+  return NS_OK;
+}
+
+template<class T>
+static bool
+EnumRulesMatching(nsIStyleRuleProcessor* aProcessor, void* aData)
+{
+  T* data = static_cast<T*>(aData);
+  aProcessor->RulesMatching(data);
+  return true;
+}
+
+static inline bool
+IsMoreSpecificThanAnimation(nsRuleNode *aRuleNode)
+{
+  return !aRuleNode->IsRoot() &&
+         (aRuleNode->GetLevel() == SheetType::Transition ||
+          aRuleNode->IsImportantRule());
+}
+
+static nsIStyleRule*
+GetAnimationRule(nsRuleNode *aRuleNode)
+{
+  nsRuleNode *n = aRuleNode;
+  while (IsMoreSpecificThanAnimation(n)) {
+    n = n->GetParent();
+  }
+
+  if (n->IsRoot() || n->GetLevel() != SheetType::Animation) {
+    return nullptr;
+  }
+
+  return n->GetRule();
+}
+
+static nsRuleNode*
+ReplaceAnimationRule(nsRuleNode *aOldRuleNode,
+                     nsIStyleRule *aOldAnimRule,
+                     nsIStyleRule *aNewAnimRule)
+{
+  nsTArray<nsRuleNode*> moreSpecificNodes;
+
+  nsRuleNode *n = aOldRuleNode;
+  while (IsMoreSpecificThanAnimation(n)) {
+    moreSpecificNodes.AppendElement(n);
+    n = n->GetParent();
+  }
+
+  if (aOldAnimRule) {
+    MOZ_ASSERT(n->GetRule() == aOldAnimRule, "wrong rule");
+    MOZ_ASSERT(n->GetLevel() == SheetType::Animation,
+               "wrong level");
+    n = n->GetParent();
+  }
+
+  MOZ_ASSERT(!IsMoreSpecificThanAnimation(n) &&
+             (n->IsRoot() || n->GetLevel() != SheetType::Animation),
+             "wrong level");
+
+  if (aNewAnimRule) {
+    n = n->Transition(aNewAnimRule, SheetType::Animation, false);
+    n->SetIsAnimationRule();
+  }
+
+  for (uint32_t i = moreSpecificNodes.Length(); i-- != 0; ) {
+    nsRuleNode *oldNode = moreSpecificNodes[i];
+    n = n->Transition(oldNode->GetRule(), oldNode->GetLevel(),
+                      oldNode->IsImportantRule());
+  }
+
+  return n;
+}
+
+/**
+ * |GetContext| implements sharing of style contexts (not just the data
+ * on the rule nodes) between siblings and cousins of the same
+ * generation.  (It works for cousins of the same generation since
+ * |aParentContext| could itself be a shared context.)
+ */
+already_AddRefed<nsStyleContext>
+nsStyleSet::GetContext(nsStyleContext* aParentContext,
+                       nsRuleNode* aRuleNode,
+                       // aVisitedRuleNode may be null; if it is null
+                       // it means that we don't need to force creation
+                       // of a StyleIfVisited.  (But if we make one
+                       // because aParentContext has one, then aRuleNode
+                       // should be used.)
+                       nsRuleNode* aVisitedRuleNode,
+                       nsIAtom* aPseudoTag,
+                       CSSPseudoElementType aPseudoType,
+                       Element* aElementForAnimation,
+                       uint32_t aFlags)
+{
+  NS_PRECONDITION((!aPseudoTag &&
+                   aPseudoType ==
+                     CSSPseudoElementType::NotPseudo) ||
+                  (aPseudoTag &&
+                   nsCSSPseudoElements::GetPseudoType(
+                     aPseudoTag, CSSEnabledState::eIgnoreEnabledState) ==
+                   aPseudoType),
+                  "Pseudo mismatch");
+
+  if (aVisitedRuleNode == aRuleNode) {
+    // No need to force creation of a visited style in this case.
+    aVisitedRuleNode = nullptr;
+  }
+
+  // Ensure |aVisitedRuleNode != nullptr| corresponds to the need to
+  // create an if-visited style context, and that in that case, we have
+  // parentIfVisited set correctly.
+  nsStyleContext *parentIfVisited =
+    aParentContext ? aParentContext->GetStyleIfVisited() : nullptr;
+  if (parentIfVisited) {
+    if (!aVisitedRuleNode) {
+      aVisitedRuleNode = aRuleNode;
+    }
+  } else {
+    if (aVisitedRuleNode) {
+      parentIfVisited = aParentContext;
+    }
+  }
+
+  if (aFlags & eIsLink) {
+    // If this node is a link, we want its visited's style context's
+    // parent to be the regular style context of its parent, because
+    // only the visitedness of the relevant link should influence style.
+    parentIfVisited = aParentContext;
+  }
+
+  bool relevantLinkVisited = (aFlags & eIsLink) ?
+    (aFlags & eIsVisitedLink) :
+    (aParentContext && aParentContext->RelevantLinkVisited());
+
+  RefPtr<nsStyleContext> result;
+  if (aParentContext)
+    result = aParentContext->FindChildWithRules(aPseudoTag, aRuleNode,
+                                                aVisitedRuleNode,
+                                                relevantLinkVisited);
+
+  if (!result) {
+    // |aVisitedRuleNode| may have a ref-count of zero since we are yet
+    // to create the style context that will hold an owning reference to it.
+    // As a result, we need to make sure it stays alive until that point
+    // in case something in the first call to NS_NewStyleContext triggers a
+    // GC sweep of rule nodes.
+    RefPtr<nsRuleNode> kungFuDeathGrip{aVisitedRuleNode};
+
+    result = NS_NewStyleContext(aParentContext, aPseudoTag, aPseudoType,
+                                aRuleNode,
+                                aFlags & eSkipParentDisplayBasedStyleFixup);
+    if (aVisitedRuleNode) {
+      RefPtr<nsStyleContext> resultIfVisited =
+        NS_NewStyleContext(parentIfVisited, aPseudoTag, aPseudoType,
+                           aVisitedRuleNode,
+                           aFlags & eSkipParentDisplayBasedStyleFixup);
+      resultIfVisited->SetIsStyleIfVisited();
+      result->SetStyleIfVisited(resultIfVisited.forget());
+
+      if (relevantLinkVisited) {
+        result->AddStyleBit(NS_STYLE_RELEVANT_LINK_VISITED);
+      }
+    }
+  }
+  else {
+    NS_ASSERTION(result->GetPseudoType() == aPseudoType, "Unexpected type");
+    NS_ASSERTION(result->GetPseudo() == aPseudoTag, "Unexpected pseudo");
+  }
+
+  if (aFlags & eDoAnimation) {
+
+    nsIStyleRule *oldAnimRule = GetAnimationRule(aRuleNode);
+    nsIStyleRule *animRule = nullptr;
+
+    // Ignore animations for print or print preview, and for elements
+    // that are not attached to the document tree.
+    if (PresContext()->IsDynamic() &&
+        aElementForAnimation->IsInComposedDoc()) {
+      // Update CSS animations in case the animation-name has just changed.
+      PresContext()->AnimationManager()->UpdateAnimations(result,
+                                                          aElementForAnimation);
+      PresContext()->EffectCompositor()->UpdateEffectProperties(
+        result, aElementForAnimation, result->GetPseudoType());
+
+      animRule = PresContext()->EffectCompositor()->
+                   GetAnimationRule(aElementForAnimation,
+                                    result->GetPseudoType(),
+                                    EffectCompositor::CascadeLevel::Animations,
+                                    result);
+    }
+
+    MOZ_ASSERT(result->RuleNode() == aRuleNode,
+               "unexpected rule node");
+    MOZ_ASSERT(!result->GetStyleIfVisited() == !aVisitedRuleNode,
+               "unexpected visited rule node");
+    MOZ_ASSERT(!aVisitedRuleNode ||
+               result->GetStyleIfVisited()->RuleNode() == aVisitedRuleNode,
+               "unexpected visited rule node");
+    MOZ_ASSERT(!aVisitedRuleNode ||
+               oldAnimRule == GetAnimationRule(aVisitedRuleNode),
+               "animation rule mismatch between rule nodes");
+    if (oldAnimRule != animRule) {
+      nsRuleNode *ruleNode =
+        ReplaceAnimationRule(aRuleNode, oldAnimRule, animRule);
+      nsRuleNode *visitedRuleNode = aVisitedRuleNode
+        ? ReplaceAnimationRule(aVisitedRuleNode, oldAnimRule, animRule)
+        : nullptr;
+      MOZ_ASSERT(!visitedRuleNode ||
+                 GetAnimationRule(ruleNode) ==
+                   GetAnimationRule(visitedRuleNode),
+                 "animation rule mismatch between rule nodes");
+      result = GetContext(aParentContext, ruleNode, visitedRuleNode,
+                          aPseudoTag, aPseudoType, nullptr,
+                          aFlags & ~eDoAnimation);
+    }
+  }
+
+  if (aElementForAnimation &&
+      aElementForAnimation->IsHTMLElement(nsGkAtoms::body) &&
+      aPseudoType == CSSPseudoElementType::NotPseudo &&
+      PresContext()->CompatibilityMode() == eCompatibility_NavQuirks) {
+    nsIDocument* doc = aElementForAnimation->GetUncomposedDoc();
+    if (doc && doc->GetBodyElement() == aElementForAnimation) {
+      // Update the prescontext's body color
+      PresContext()->SetBodyTextColor(result->StyleColor()->mColor);
+    }
+  }
+
+  return result.forget();
+}
+
+void
+nsStyleSet::AddImportantRules(nsRuleNode* aCurrLevelNode,
+                              nsRuleNode* aLastPrevLevelNode,
+                              nsRuleWalker* aRuleWalker)
+{
+  NS_ASSERTION(aCurrLevelNode &&
+               aCurrLevelNode != aLastPrevLevelNode, "How did we get here?");
+
+  AutoTArray<nsIStyleRule*, 16> importantRules;
+  for (nsRuleNode *node = aCurrLevelNode; node != aLastPrevLevelNode;
+       node = node->GetParent()) {
+    // We guarantee that we never walk the root node here, so no need
+    // to null-check GetRule().  Furthermore, it must be a CSS rule.
+    NS_ASSERTION(RefPtr<css::Declaration>(do_QueryObject(node->GetRule())),
+                 "Unexpected non-CSS rule");
+
+    nsIStyleRule* impRule =
+      static_cast<css::Declaration*>(node->GetRule())->GetImportantStyleData();
+    if (impRule)
+      importantRules.AppendElement(impRule);
+  }
+
+  NS_ASSERTION(importantRules.Length() != 0,
+               "Why did we think there were important rules?");
+
+  for (uint32_t i = importantRules.Length(); i-- != 0; ) {
+    aRuleWalker->Forward(importantRules[i]);
+  }
+}
+
+#ifdef DEBUG
+void
+nsStyleSet::AssertNoImportantRules(nsRuleNode* aCurrLevelNode,
+                                   nsRuleNode* aLastPrevLevelNode)
+{
+  if (!aCurrLevelNode)
+    return;
+
+  for (nsRuleNode *node = aCurrLevelNode; node != aLastPrevLevelNode;
+       node = node->GetParent()) {
+    RefPtr<css::Declaration> declaration(do_QueryObject(node->GetRule()));
+    NS_ASSERTION(declaration, "Unexpected non-CSS rule");
+
+    NS_ASSERTION(!declaration->GetImportantStyleData(),
+                 "Unexpected important style source");
+  }
+}
+
+void
+nsStyleSet::AssertNoCSSRules(nsRuleNode* aCurrLevelNode,
+                             nsRuleNode* aLastPrevLevelNode)
+{
+  if (!aCurrLevelNode)
+    return;
+
+  for (nsRuleNode *node = aCurrLevelNode; node != aLastPrevLevelNode;
+       node = node->GetParent()) {
+    nsIStyleRule *rule = node->GetRule();
+    RefPtr<css::Declaration> declaration(do_QueryObject(rule));
+    if (declaration) {
+      RefPtr<css::StyleRule> cssRule =
+        do_QueryObject(declaration->GetOwningRule());
+      NS_ASSERTION(!cssRule || !cssRule->Selector(),
+                   "Unexpected CSS rule");
+    }
+  }
+}
+#endif
+
+// Enumerate the rules in a way that cares about the order of the rules.
+void
+nsStyleSet::FileRules(nsIStyleRuleProcessor::EnumFunc aCollectorFunc,
+                      RuleProcessorData* aData, Element* aElement,
+                      nsRuleWalker* aRuleWalker)
+{
+  PROFILER_LABEL("nsStyleSet", "FileRules",
+    js::ProfileEntry::Category::CSS);
+
+  NS_ASSERTION(mBatching == 0, "rule processors out of date");
+
+  // Cascading order:
+  // [least important]
+  //  - UA normal rules                    = Agent        normal
+  //  - User normal rules                  = User         normal
+  //  - Presentation hints                 = PresHint     normal
+  //  - SVG Animation (highest pres hint)  = SVGAttrAnimation normal
+  //  - Author normal rules                = Document     normal
+  //  - Override normal rules              = Override     normal
+  //  - animation rules                    = Animation    normal
+  //  - Author !important rules            = Document     !important
+  //  - Override !important rules          = Override     !important
+  //  - User !important rules              = User         !important
+  //  - UA !important rules                = Agent        !important
+  //  - transition rules                   = Transition   normal
+  // [most important]
+
+  // Save off the last rule before we start walking our agent sheets;
+  // this will be either the root or one of the restriction rules.
+  nsRuleNode* lastRestrictionRN = aRuleWalker->CurrentNode();
+
+  aRuleWalker->SetLevel(SheetType::Agent, false, true);
+  if (mRuleProcessors[SheetType::Agent])
+    (*aCollectorFunc)(mRuleProcessors[SheetType::Agent], aData);
+  nsRuleNode* lastAgentRN = aRuleWalker->CurrentNode();
+  bool haveImportantUARules = !aRuleWalker->GetCheckForImportantRules();
+
+  aRuleWalker->SetLevel(SheetType::User, false, true);
+  bool skipUserStyles =
+    aElement && aElement->IsInNativeAnonymousSubtree();
+  if (!skipUserStyles && mRuleProcessors[SheetType::User]) // NOTE: different
+    (*aCollectorFunc)(mRuleProcessors[SheetType::User], aData);
+  nsRuleNode* lastUserRN = aRuleWalker->CurrentNode();
+  bool haveImportantUserRules = !aRuleWalker->GetCheckForImportantRules();
+
+  aRuleWalker->SetLevel(SheetType::PresHint, false, false);
+  if (mRuleProcessors[SheetType::PresHint])
+    (*aCollectorFunc)(mRuleProcessors[SheetType::PresHint], aData);
+
+  aRuleWalker->SetLevel(SheetType::SVGAttrAnimation, false, false);
+  if (mRuleProcessors[SheetType::SVGAttrAnimation])
+    (*aCollectorFunc)(mRuleProcessors[SheetType::SVGAttrAnimation], aData);
+  nsRuleNode* lastSVGAttrAnimationRN = aRuleWalker->CurrentNode();
+
+  aRuleWalker->SetLevel(SheetType::Doc, false, true);
+  bool cutOffInheritance = false;
+  if (mBindingManager && aElement) {
+    // We can supply additional document-level sheets that should be walked.
+    mBindingManager->WalkRules(aCollectorFunc,
+                               static_cast<ElementDependentRuleProcessorData*>(aData),
+                               &cutOffInheritance);
+  }
+  if (!skipUserStyles && !cutOffInheritance && // NOTE: different
+      mRuleProcessors[SheetType::Doc])
+    (*aCollectorFunc)(mRuleProcessors[SheetType::Doc], aData);
+  nsRuleNode* lastDocRN = aRuleWalker->CurrentNode();
+  bool haveImportantDocRules = !aRuleWalker->GetCheckForImportantRules();
+  nsTArray<nsRuleNode*> lastScopedRNs;
+  nsTArray<bool> haveImportantScopedRules;
+  bool haveAnyImportantScopedRules = false;
+  if (!skipUserStyles && !cutOffInheritance &&
+      aElement && aElement->IsElementInStyleScope()) {
+    lastScopedRNs.SetLength(mScopedDocSheetRuleProcessors.Length());
+    haveImportantScopedRules.SetLength(mScopedDocSheetRuleProcessors.Length());
+    for (uint32_t i = 0; i < mScopedDocSheetRuleProcessors.Length(); i++) {
+      aRuleWalker->SetLevel(SheetType::ScopedDoc, false, true);
+      nsCSSRuleProcessor* processor =
+        static_cast<nsCSSRuleProcessor*>(mScopedDocSheetRuleProcessors[i].get());
+      aData->mScope = processor->GetScopeElement();
+      (*aCollectorFunc)(mScopedDocSheetRuleProcessors[i], aData);
+      lastScopedRNs[i] = aRuleWalker->CurrentNode();
+      haveImportantScopedRules[i] = !aRuleWalker->GetCheckForImportantRules();
+      haveAnyImportantScopedRules = haveAnyImportantScopedRules || haveImportantScopedRules[i];
+    }
+    aData->mScope = nullptr;
+  }
+  nsRuleNode* lastScopedRN = aRuleWalker->CurrentNode();
+  aRuleWalker->SetLevel(SheetType::StyleAttr, false, true);
+  if (mRuleProcessors[SheetType::StyleAttr])
+    (*aCollectorFunc)(mRuleProcessors[SheetType::StyleAttr], aData);
+  nsRuleNode* lastStyleAttrRN = aRuleWalker->CurrentNode();
+  bool haveImportantStyleAttrRules = !aRuleWalker->GetCheckForImportantRules();
+
+  aRuleWalker->SetLevel(SheetType::Override, false, true);
+  if (mRuleProcessors[SheetType::Override])
+    (*aCollectorFunc)(mRuleProcessors[SheetType::Override], aData);
+  nsRuleNode* lastOvrRN = aRuleWalker->CurrentNode();
+  bool haveImportantOverrideRules = !aRuleWalker->GetCheckForImportantRules();
+
+  // This needs to match IsMoreSpecificThanAnimation() above.
+  aRuleWalker->SetLevel(SheetType::Animation, false, false);
+  (*aCollectorFunc)(mRuleProcessors[SheetType::Animation], aData);
+
+  if (haveAnyImportantScopedRules) {
+    for (uint32_t i = lastScopedRNs.Length(); i-- != 0; ) {
+      aRuleWalker->SetLevel(SheetType::ScopedDoc, true, false);
+      nsRuleNode* startRN = lastScopedRNs[i];
+      nsRuleNode* endRN = i == 0 ? lastDocRN : lastScopedRNs[i - 1];
+      if (haveImportantScopedRules[i]) {
+        AddImportantRules(startRN, endRN, aRuleWalker);  // scoped
+      }
+#ifdef DEBUG
+      else {
+        AssertNoImportantRules(startRN, endRN);
+      }
+#endif
+    }
+  }
+#ifdef DEBUG
+  else {
+    AssertNoImportantRules(lastScopedRN, lastDocRN);
+  }
+#endif
+
+  if (haveImportantDocRules) {
+    aRuleWalker->SetLevel(SheetType::Doc, true, false);
+    AddImportantRules(lastDocRN, lastSVGAttrAnimationRN, aRuleWalker);  // doc
+  }
+#ifdef DEBUG
+  else {
+    AssertNoImportantRules(lastDocRN, lastSVGAttrAnimationRN);
+  }
+#endif
+
+  if (haveImportantStyleAttrRules) {
+    aRuleWalker->SetLevel(SheetType::StyleAttr, true, false);
+    AddImportantRules(lastStyleAttrRN, lastScopedRN, aRuleWalker);  // style attr
+  }
+#ifdef DEBUG
+  else {
+    AssertNoImportantRules(lastStyleAttrRN, lastScopedRN);
+  }
+#endif
+
+  if (haveImportantOverrideRules) {
+    aRuleWalker->SetLevel(SheetType::Override, true, false);
+    AddImportantRules(lastOvrRN, lastStyleAttrRN, aRuleWalker);  // override
+  }
+#ifdef DEBUG
+  else {
+    AssertNoImportantRules(lastOvrRN, lastStyleAttrRN);
+  }
+#endif
+
+#ifdef DEBUG
+  AssertNoCSSRules(lastSVGAttrAnimationRN, lastUserRN);
+#endif
+
+  if (haveImportantUserRules) {
+    aRuleWalker->SetLevel(SheetType::User, true, false);
+    AddImportantRules(lastUserRN, lastAgentRN, aRuleWalker); //user
+  }
+#ifdef DEBUG
+  else {
+    AssertNoImportantRules(lastUserRN, lastAgentRN);
+  }
+#endif
+
+  if (haveImportantUARules) {
+    aRuleWalker->SetLevel(SheetType::Agent, true, false);
+    AddImportantRules(lastAgentRN, lastRestrictionRN, aRuleWalker); //agent
+  }
+#ifdef DEBUG
+  else {
+    AssertNoImportantRules(lastAgentRN, lastRestrictionRN);
+  }
+#endif
+
+#ifdef DEBUG
+  AssertNoCSSRules(lastRestrictionRN, mRuleTree);
+#endif
+
+#ifdef DEBUG
+  nsRuleNode *lastImportantRN = aRuleWalker->CurrentNode();
+#endif
+  aRuleWalker->SetLevel(SheetType::Transition, false, false);
+  (*aCollectorFunc)(mRuleProcessors[SheetType::Transition], aData);
+#ifdef DEBUG
+  AssertNoCSSRules(aRuleWalker->CurrentNode(), lastImportantRN);
+#endif
+
+}
+
+// Enumerate all the rules in a way that doesn't care about the order
+// of the rules and doesn't walk !important-rules.
+void
+nsStyleSet::WalkRuleProcessors(nsIStyleRuleProcessor::EnumFunc aFunc,
+                               ElementDependentRuleProcessorData* aData,
+                               bool aWalkAllXBLStylesheets)
+{
+  NS_ASSERTION(mBatching == 0, "rule processors out of date");
+
+  if (mRuleProcessors[SheetType::Agent])
+    (*aFunc)(mRuleProcessors[SheetType::Agent], aData);
+
+  bool skipUserStyles = aData->mElement->IsInNativeAnonymousSubtree();
+  if (!skipUserStyles && mRuleProcessors[SheetType::User]) // NOTE: different
+    (*aFunc)(mRuleProcessors[SheetType::User], aData);
+
+  if (mRuleProcessors[SheetType::PresHint])
+    (*aFunc)(mRuleProcessors[SheetType::PresHint], aData);
+
+  if (mRuleProcessors[SheetType::SVGAttrAnimation])
+    (*aFunc)(mRuleProcessors[SheetType::SVGAttrAnimation], aData);
+
+  bool cutOffInheritance = false;
+  if (mBindingManager) {
+    // We can supply additional document-level sheets that should be walked.
+    if (aWalkAllXBLStylesheets) {
+      mBindingManager->WalkAllRules(aFunc, aData);
+    } else {
+      mBindingManager->WalkRules(aFunc, aData, &cutOffInheritance);
+    }
+  }
+  if (!skipUserStyles && !cutOffInheritance) {
+    if (mRuleProcessors[SheetType::Doc]) // NOTE: different
+      (*aFunc)(mRuleProcessors[SheetType::Doc], aData);
+    if (aData->mElement->IsElementInStyleScope()) {
+      for (uint32_t i = 0; i < mScopedDocSheetRuleProcessors.Length(); i++)
+        (*aFunc)(mScopedDocSheetRuleProcessors[i], aData);
+    }
+  }
+  if (mRuleProcessors[SheetType::StyleAttr])
+    (*aFunc)(mRuleProcessors[SheetType::StyleAttr], aData);
+  if (mRuleProcessors[SheetType::Override])
+    (*aFunc)(mRuleProcessors[SheetType::Override], aData);
+  (*aFunc)(mRuleProcessors[SheetType::Animation], aData);
+  (*aFunc)(mRuleProcessors[SheetType::Transition], aData);
+}
+
+static void
+InitStyleScopes(TreeMatchContext& aTreeContext, Element* aElement)
+{
+  if (aElement->IsElementInStyleScope()) {
+    aTreeContext.InitStyleScopes(aElement->GetParentElementCrossingShadowRoot());
+  }
+}
+
+already_AddRefed<nsStyleContext>
+nsStyleSet::ResolveStyleFor(Element* aElement,
+                            nsStyleContext* aParentContext)
+{
+  TreeMatchContext treeContext(true, nsRuleWalker::eRelevantLinkUnvisited,
+                               aElement->OwnerDoc());
+  InitStyleScopes(treeContext, aElement);
+  return ResolveStyleFor(aElement, aParentContext, treeContext);
+}
+
+already_AddRefed<nsStyleContext>
+nsStyleSet::ResolveStyleFor(Element* aElement,
+                            nsStyleContext* aParentContext,
+                            TreeMatchContext& aTreeMatchContext)
+{
+  NS_ENSURE_FALSE(mInShutdown, nullptr);
+  NS_ASSERTION(aElement, "aElement must not be null");
+
+  nsRuleWalker ruleWalker(mRuleTree, mAuthorStyleDisabled);
+  aTreeMatchContext.ResetForUnvisitedMatching();
+  ElementRuleProcessorData data(PresContext(), aElement, &ruleWalker,
+                                aTreeMatchContext);
+  WalkDisableTextZoomRule(aElement, &ruleWalker);
+  FileRules(EnumRulesMatching<ElementRuleProcessorData>, &data, aElement,
+            &ruleWalker);
+
+  nsRuleNode *ruleNode = ruleWalker.CurrentNode();
+  nsRuleNode *visitedRuleNode = nullptr;
+
+  if (aTreeMatchContext.HaveRelevantLink()) {
+    aTreeMatchContext.ResetForVisitedMatching();
+    ruleWalker.Reset();
+    FileRules(EnumRulesMatching<ElementRuleProcessorData>, &data, aElement,
+              &ruleWalker);
+    visitedRuleNode = ruleWalker.CurrentNode();
+  }
+
+  uint32_t flags = eDoAnimation;
+  if (nsCSSRuleProcessor::IsLink(aElement)) {
+    flags |= eIsLink;
+  }
+  if (nsCSSRuleProcessor::GetContentState(aElement, aTreeMatchContext).
+                            HasState(NS_EVENT_STATE_VISITED)) {
+    flags |= eIsVisitedLink;
+  }
+  if (aTreeMatchContext.mSkippingParentDisplayBasedStyleFixup) {
+    flags |= eSkipParentDisplayBasedStyleFixup;
+  }
+
+  return GetContext(aParentContext, ruleNode, visitedRuleNode,
+                    nullptr, CSSPseudoElementType::NotPseudo,
+                    aElement, flags);
+}
+
+already_AddRefed<nsStyleContext>
+nsStyleSet::ResolveStyleForRules(nsStyleContext* aParentContext,
+                                 const nsTArray< nsCOMPtr<nsIStyleRule> > &aRules)
+{
+  NS_ENSURE_FALSE(mInShutdown, nullptr);
+
+  nsRuleWalker ruleWalker(mRuleTree, mAuthorStyleDisabled);
+  // FIXME: Perhaps this should be passed in, but it probably doesn't
+  // matter.
+  ruleWalker.SetLevel(SheetType::Doc, false, false);
+  for (uint32_t i = 0; i < aRules.Length(); i++) {
+    ruleWalker.ForwardOnPossiblyCSSRule(aRules.ElementAt(i));
+  }
+
+  return GetContext(aParentContext, ruleWalker.CurrentNode(), nullptr,
+                    nullptr, CSSPseudoElementType::NotPseudo,
+                    nullptr, eNoFlags);
+}
+
+already_AddRefed<nsStyleContext>
+nsStyleSet::ResolveStyleByAddingRules(nsStyleContext* aBaseContext,
+                                      const nsCOMArray<nsIStyleRule> &aRules)
+{
+  NS_ENSURE_FALSE(mInShutdown, nullptr);
+
+  nsRuleWalker ruleWalker(mRuleTree, mAuthorStyleDisabled);
+  ruleWalker.SetCurrentNode(aBaseContext->RuleNode());
+  // This needs to be the transition sheet because that is the highest
+  // level of the cascade, and thus the only thing that makes sense if
+  // we are ever going to call ResolveStyleWithReplacement on the
+  // resulting context.  It's also the right thing for the one case (the
+  // transition manager's cover rule) where we put the result of this
+  // function in the style context tree.
+  ruleWalker.SetLevel(SheetType::Transition, false, false);
+  for (int32_t i = 0; i < aRules.Count(); i++) {
+    ruleWalker.ForwardOnPossiblyCSSRule(aRules.ObjectAt(i));
+  }
+
+  nsRuleNode *ruleNode = ruleWalker.CurrentNode();
+  nsRuleNode *visitedRuleNode = nullptr;
+
+  if (aBaseContext->GetStyleIfVisited()) {
+    ruleWalker.SetCurrentNode(aBaseContext->GetStyleIfVisited()->RuleNode());
+    for (int32_t i = 0; i < aRules.Count(); i++) {
+      ruleWalker.ForwardOnPossiblyCSSRule(aRules.ObjectAt(i));
+    }
+    visitedRuleNode = ruleWalker.CurrentNode();
+  }
+
+  uint32_t flags = eNoFlags;
+  if (aBaseContext->IsLinkContext()) {
+    flags |= eIsLink;
+
+    // GetContext handles propagating RelevantLinkVisited state from the
+    // parent in non-link cases; all we need to pass in is if this link
+    // is visited.
+    if (aBaseContext->RelevantLinkVisited()) {
+      flags |= eIsVisitedLink;
+    }
+  }
+  return GetContext(aBaseContext->GetParent(), ruleNode, visitedRuleNode,
+                    aBaseContext->GetPseudo(),
+                    aBaseContext->GetPseudoType(),
+                    nullptr, flags);
+}
+
+struct RuleNodeInfo {
+  nsIStyleRule* mRule;
+  SheetType mLevel;
+  bool mIsImportant;
+  bool mIsAnimationRule;
+};
+
+struct CascadeLevel {
+  SheetType mLevel;
+  bool mIsImportant;
+  bool mCheckForImportantRules;
+  nsRestyleHint mLevelReplacementHint;
+};
+
+static const CascadeLevel gCascadeLevels[] = {
+  { SheetType::Agent,            false, false, nsRestyleHint(0) },
+  { SheetType::User,             false, false, nsRestyleHint(0) },
+  { SheetType::PresHint,         false, false, nsRestyleHint(0) },
+  { SheetType::SVGAttrAnimation, false, false, eRestyle_SVGAttrAnimations },
+  { SheetType::Doc,              false, false, nsRestyleHint(0) },
+  { SheetType::ScopedDoc,        false, false, nsRestyleHint(0) },
+  { SheetType::StyleAttr,        false, true,  eRestyle_StyleAttribute |
+                                               eRestyle_StyleAttribute_Animations },
+  { SheetType::Override,         false, false, nsRestyleHint(0) },
+  { SheetType::Animation,        false, false, eRestyle_CSSAnimations },
+  { SheetType::ScopedDoc,        true,  false, nsRestyleHint(0) },
+  { SheetType::Doc,              true,  false, nsRestyleHint(0) },
+  { SheetType::StyleAttr,        true,  false, eRestyle_StyleAttribute |
+                                               eRestyle_StyleAttribute_Animations },
+  { SheetType::Override,         true,  false, nsRestyleHint(0) },
+  { SheetType::User,             true,  false, nsRestyleHint(0) },
+  { SheetType::Agent,            true,  false, nsRestyleHint(0) },
+  { SheetType::Transition,       false, false, eRestyle_CSSTransitions },
+};
+
+nsRuleNode*
+nsStyleSet::RuleNodeWithReplacement(Element* aElement,
+                                    Element* aPseudoElement,
+                                    nsRuleNode* aOldRuleNode,
+                                    CSSPseudoElementType aPseudoType,
+                                    nsRestyleHint aReplacements)
+{
+  NS_ASSERTION(mBatching == 0, "rule processors out of date");
+
+  MOZ_ASSERT(!aPseudoElement ==
+             (aPseudoType >= CSSPseudoElementType::Count ||
+              !(nsCSSPseudoElements::PseudoElementSupportsStyleAttribute(aPseudoType) ||
+                nsCSSPseudoElements::PseudoElementSupportsUserActionState(aPseudoType))),
+             "should have aPseudoElement only for certain pseudo elements");
+
+  MOZ_ASSERT(!(aReplacements & ~(eRestyle_CSSTransitions |
+                                 eRestyle_CSSAnimations |
+                                 eRestyle_SVGAttrAnimations |
+                                 eRestyle_StyleAttribute |
+                                 eRestyle_StyleAttribute_Animations |
+                                 eRestyle_Force |
+                                 eRestyle_ForceDescendants)),
+             "unexpected replacement bits");
+
+  // FIXME (perf): This should probably not rebuild the whole path, but
+  // only the path from the last change in the rule tree, like
+  // ReplaceAnimationRule in nsStyleSet.cpp does.  (That could then
+  // perhaps share this code, too?)
+  // But if we do that, we'll need to pass whether we are rebuilding the
+  // rule tree from ElementRestyler::RestyleSelf to avoid taking that
+  // path when we're rebuilding the rule tree.
+
+  // This array can be hot and often grows to ~20 elements, so inline storage
+  // is best.
+  AutoTArray<RuleNodeInfo, 30> rules;
+  for (nsRuleNode* ruleNode = aOldRuleNode; !ruleNode->IsRoot();
+       ruleNode = ruleNode->GetParent()) {
+    RuleNodeInfo* curRule = rules.AppendElement();
+    curRule->mRule = ruleNode->GetRule();
+    curRule->mLevel = ruleNode->GetLevel();
+    curRule->mIsImportant = ruleNode->IsImportantRule();
+    curRule->mIsAnimationRule = ruleNode->IsAnimationRule();
+  }
+
+  nsRuleWalker ruleWalker(mRuleTree, mAuthorStyleDisabled);
+  auto rulesIndex = rules.Length();
+
+  // We need to transfer this information between the non-!important and
+  // !important phases for the style attribute level.
+  nsRuleNode* lastScopedRN = nullptr;
+  nsRuleNode* lastStyleAttrRN = nullptr;
+  bool haveImportantStyleAttrRules = false;
+
+  for (const CascadeLevel *level = gCascadeLevels,
+                       *levelEnd = ArrayEnd(gCascadeLevels);
+       level != levelEnd; ++level) {
+
+    bool doReplace = level->mLevelReplacementHint & aReplacements;
+
+    ruleWalker.SetLevel(level->mLevel, level->mIsImportant,
+                        level->mCheckForImportantRules && doReplace);
+
+    if (doReplace) {
+      switch (level->mLevel) {
+        case SheetType::Animation: {
+          if (aPseudoType == CSSPseudoElementType::NotPseudo ||
+              aPseudoType == CSSPseudoElementType::before ||
+              aPseudoType == CSSPseudoElementType::after) {
+            nsIStyleRule* rule = PresContext()->EffectCompositor()->
+              GetAnimationRule(aElement, aPseudoType,
+                               EffectCompositor::CascadeLevel::Animations,
+                               nullptr);
+            if (rule) {
+              ruleWalker.ForwardOnPossiblyCSSRule(rule);
+              ruleWalker.CurrentNode()->SetIsAnimationRule();
+            }
+          }
+          break;
+        }
+        case SheetType::Transition: {
+          if (aPseudoType == CSSPseudoElementType::NotPseudo ||
+              aPseudoType == CSSPseudoElementType::before ||
+              aPseudoType == CSSPseudoElementType::after) {
+            nsIStyleRule* rule = PresContext()->EffectCompositor()->
+              GetAnimationRule(aElement, aPseudoType,
+                               EffectCompositor::CascadeLevel::Transitions,
+                               nullptr);
+            if (rule) {
+              ruleWalker.ForwardOnPossiblyCSSRule(rule);
+              ruleWalker.CurrentNode()->SetIsAnimationRule();
+            }
+          }
+          break;
+        }
+        case SheetType::SVGAttrAnimation: {
+          SVGAttrAnimationRuleProcessor* ruleProcessor =
+            static_cast<SVGAttrAnimationRuleProcessor*>(
+              mRuleProcessors[SheetType::SVGAttrAnimation].get());
+          if (ruleProcessor &&
+              aPseudoType == CSSPseudoElementType::NotPseudo) {
+            ruleProcessor->ElementRulesMatching(aElement, &ruleWalker);
+          }
+          break;
+        }
+        case SheetType::StyleAttr: {
+          if (!level->mIsImportant) {
+            // First time through, we handle the non-!important rule.
+            nsHTMLCSSStyleSheet* ruleProcessor =
+              static_cast<nsHTMLCSSStyleSheet*>(
+                mRuleProcessors[SheetType::StyleAttr].get());
+            if (ruleProcessor) {
+              lastScopedRN = ruleWalker.CurrentNode();
+              if (aPseudoType ==
+                    CSSPseudoElementType::NotPseudo) {
+                ruleProcessor->ElementRulesMatching(PresContext(),
+                                                    aElement,
+                                                    &ruleWalker);
+              } else if (aPseudoType <
+                           CSSPseudoElementType::Count &&
+                         nsCSSPseudoElements::
+                           PseudoElementSupportsStyleAttribute(aPseudoType)) {
+                ruleProcessor->PseudoElementRulesMatching(aPseudoElement,
+                                                          aPseudoType,
+                                                          &ruleWalker);
+              }
+              lastStyleAttrRN = ruleWalker.CurrentNode();
+              haveImportantStyleAttrRules =
+                !ruleWalker.GetCheckForImportantRules();
+            }
+          } else {
+            // Second time through, we handle the !important rule(s).
+            if (haveImportantStyleAttrRules) {
+              AddImportantRules(lastStyleAttrRN, lastScopedRN, &ruleWalker);
+            }
+          }
+          break;
+        }
+        default:
+          MOZ_ASSERT(false, "unexpected result from gCascadeLevels lookup");
+          break;
+      }
+    }
+
+    while (rulesIndex != 0) {
+      --rulesIndex;
+      const RuleNodeInfo& ruleInfo = rules[rulesIndex];
+
+      if (ruleInfo.mLevel != level->mLevel ||
+          ruleInfo.mIsImportant != level->mIsImportant) {
+        ++rulesIndex;
+        break;
+      }
+
+      if (!doReplace) {
+        ruleWalker.ForwardOnPossiblyCSSRule(ruleInfo.mRule);
+        if (ruleInfo.mIsAnimationRule) {
+          ruleWalker.CurrentNode()->SetIsAnimationRule();
+        }
+      }
+    }
+  }
+
+  NS_ASSERTION(rulesIndex == 0,
+               "rules are in incorrect cascading order, "
+               "which means we replaced them incorrectly");
+
+  return ruleWalker.CurrentNode();
+}
+
+already_AddRefed<nsStyleContext>
+nsStyleSet::ResolveStyleWithReplacement(Element* aElement,
+                                        Element* aPseudoElement,
+                                        nsStyleContext* aNewParentContext,
+                                        nsStyleContext* aOldStyleContext,
+                                        nsRestyleHint aReplacements,
+                                        uint32_t aFlags)
+{
+  nsRuleNode* ruleNode =
+    RuleNodeWithReplacement(aElement, aPseudoElement,
+                            aOldStyleContext->RuleNode(),
+                            aOldStyleContext->GetPseudoType(), aReplacements);
+
+  nsRuleNode* visitedRuleNode = nullptr;
+  nsStyleContext* oldStyleIfVisited = aOldStyleContext->GetStyleIfVisited();
+  if (oldStyleIfVisited) {
+    if (oldStyleIfVisited->RuleNode() == aOldStyleContext->RuleNode()) {
+      visitedRuleNode = ruleNode;
+    } else {
+      visitedRuleNode =
+        RuleNodeWithReplacement(aElement, aPseudoElement,
+                                oldStyleIfVisited->RuleNode(),
+                                oldStyleIfVisited->GetPseudoType(),
+                                aReplacements);
+    }
+  }
+
+  uint32_t flags = eNoFlags;
+  if (aOldStyleContext->IsLinkContext()) {
+    flags |= eIsLink;
+
+    // GetContext handles propagating RelevantLinkVisited state from the
+    // parent in non-link cases; all we need to pass in is if this link
+    // is visited.
+    if (aOldStyleContext->RelevantLinkVisited()) {
+      flags |= eIsVisitedLink;
+    }
+  }
+
+  CSSPseudoElementType pseudoType = aOldStyleContext->GetPseudoType();
+  Element* elementForAnimation = nullptr;
+  if (!(aFlags & eSkipStartingAnimations) &&
+      (pseudoType == CSSPseudoElementType::NotPseudo ||
+       pseudoType == CSSPseudoElementType::before ||
+       pseudoType == CSSPseudoElementType::after)) {
+    // We want to compute a correct elementForAnimation to pass in
+    // because at this point the parameter is more than just the element
+    // for animation; it's also used for the SetBodyTextColor call when
+    // it's the body element.
+    // However, we only want to set the flag to call CheckAnimationRule
+    // if we're dealing with a replacement (such as style attribute
+    // replacement) that could lead to the animation property changing,
+    // and we explicitly do NOT want to call CheckAnimationRule when
+    // we're trying to do an animation-only update.
+    if (aReplacements & ~(eRestyle_CSSTransitions | eRestyle_CSSAnimations)) {
+      flags |= eDoAnimation;
+    }
+    elementForAnimation = aElement;
+#ifdef DEBUG
+    {
+      nsIFrame* styleFrame = nsLayoutUtils::GetStyleFrame(elementForAnimation);
+      NS_ASSERTION(pseudoType == CSSPseudoElementType::NotPseudo ||
+                   !styleFrame ||
+                   styleFrame->StyleContext()->GetPseudoType() ==
+                     CSSPseudoElementType::NotPseudo,
+                   "aElement should be the element and not the pseudo-element");
+    }
+#endif
+  }
+
+  if (aElement && aElement->IsRootOfAnonymousSubtree()) {
+    // For anonymous subtree roots, don't tweak "display" value based on whether
+    // or not the parent is styled as a flex/grid container. (If the parent
+    // has anonymous-subtree kids, then we know it's not actually going to get
+    // a flex/grid container frame, anyway.)
+    flags |= eSkipParentDisplayBasedStyleFixup;
+  }
+
+  return GetContext(aNewParentContext, ruleNode, visitedRuleNode,
+                    aOldStyleContext->GetPseudo(), pseudoType,
+                    elementForAnimation, flags);
+}
+
+already_AddRefed<nsStyleContext>
+nsStyleSet::ResolveStyleWithoutAnimation(dom::Element* aTarget,
+                                         nsStyleContext* aStyleContext,
+                                         nsRestyleHint aWhichToRemove)
+{
+#ifdef DEBUG
+  CSSPseudoElementType pseudoType = aStyleContext->GetPseudoType();
+#endif
+  MOZ_ASSERT(pseudoType == CSSPseudoElementType::NotPseudo ||
+             pseudoType == CSSPseudoElementType::before ||
+             pseudoType == CSSPseudoElementType::after,
+             "unexpected type for animations");
+  MOZ_ASSERT(PresContext()->RestyleManager()->IsGecko(),
+             "stylo: the style set and restyle manager must have the same "
+             "StyleBackendType");
+  RestyleManager* restyleManager = PresContext()->RestyleManager()->AsGecko();
+
+  bool oldSkipAnimationRules = restyleManager->SkipAnimationRules();
+  restyleManager->SetSkipAnimationRules(true);
+
+  RefPtr<nsStyleContext> result =
+    ResolveStyleWithReplacement(aTarget, nullptr, aStyleContext->GetParent(),
+                                aStyleContext, aWhichToRemove,
+                                eSkipStartingAnimations);
+
+  restyleManager->SetSkipAnimationRules(oldSkipAnimationRules);
+
+  return result.forget();
+}
+
+already_AddRefed<nsStyleContext>
+nsStyleSet::ResolveStyleForText(nsIContent* aTextNode,
+                                nsStyleContext* aParentContext)
+{
+  MOZ_ASSERT(aTextNode && aTextNode->IsNodeOfType(nsINode::eTEXT));
+  return GetContext(aParentContext, mRuleTree, nullptr,
+                    nsCSSAnonBoxes::mozText,
+                    CSSPseudoElementType::AnonBox, nullptr, eNoFlags);
+}
+
+already_AddRefed<nsStyleContext>
+nsStyleSet::ResolveStyleForOtherNonElement(nsStyleContext* aParentContext)
+{
+  return GetContext(aParentContext, mRuleTree, nullptr,
+                    nsCSSAnonBoxes::mozOtherNonElement,
+                    CSSPseudoElementType::AnonBox, nullptr, eNoFlags);
+}
+
+void
+nsStyleSet::WalkRestrictionRule(CSSPseudoElementType aPseudoType,
+                                nsRuleWalker* aRuleWalker)
+{
+  // This needs to match GetPseudoRestriction in nsRuleNode.cpp.
+  aRuleWalker->SetLevel(SheetType::Agent, false, false);
+  if (aPseudoType == CSSPseudoElementType::firstLetter)
+    aRuleWalker->Forward(mFirstLetterRule);
+  else if (aPseudoType == CSSPseudoElementType::firstLine)
+    aRuleWalker->Forward(mFirstLineRule);
+  else if (aPseudoType == CSSPseudoElementType::placeholder)
+    aRuleWalker->Forward(mPlaceholderRule);
+}
+
+void
+nsStyleSet::WalkDisableTextZoomRule(Element* aElement, nsRuleWalker* aRuleWalker)
+{
+  aRuleWalker->SetLevel(SheetType::Agent, false, false);
+  if (aElement->IsSVGElement(nsGkAtoms::text))
+    aRuleWalker->Forward(mDisableTextZoomStyleRule);
+}
+
+already_AddRefed<nsStyleContext>
+nsStyleSet::ResolvePseudoElementStyle(Element* aParentElement,
+                                      CSSPseudoElementType aType,
+                                      nsStyleContext* aParentContext,
+                                      Element* aPseudoElement)
+{
+  NS_ENSURE_FALSE(mInShutdown, nullptr);
+
+  NS_ASSERTION(aType < CSSPseudoElementType::Count,
+               "must have pseudo element type");
+  NS_ASSERTION(aParentElement, "Must have parent element");
+
+  nsRuleWalker ruleWalker(mRuleTree, mAuthorStyleDisabled);
+  TreeMatchContext treeContext(true, nsRuleWalker::eRelevantLinkUnvisited,
+                               aParentElement->OwnerDoc());
+  InitStyleScopes(treeContext, aParentElement);
+  PseudoElementRuleProcessorData data(PresContext(), aParentElement,
+                                      &ruleWalker, aType, treeContext,
+                                      aPseudoElement);
+  WalkRestrictionRule(aType, &ruleWalker);
+  FileRules(EnumRulesMatching<PseudoElementRuleProcessorData>, &data,
+            aParentElement, &ruleWalker);
+
+  nsRuleNode *ruleNode = ruleWalker.CurrentNode();
+  nsRuleNode *visitedRuleNode = nullptr;
+
+  if (treeContext.HaveRelevantLink()) {
+    treeContext.ResetForVisitedMatching();
+    ruleWalker.Reset();
+    WalkRestrictionRule(aType, &ruleWalker);
+    FileRules(EnumRulesMatching<PseudoElementRuleProcessorData>, &data,
+              aParentElement, &ruleWalker);
+    visitedRuleNode = ruleWalker.CurrentNode();
+  }
+
+  // For pseudos, |data.IsLink()| being true means that
+  // our parent node is a link.
+  uint32_t flags = eNoFlags;
+  if (aType == CSSPseudoElementType::before ||
+      aType == CSSPseudoElementType::after) {
+    flags |= eDoAnimation;
+  } else {
+    // Flex and grid containers don't expect to have any pseudo-element children
+    // aside from ::before and ::after.  So if we have such a child, we're not
+    // actually in a flex/grid container, and we should skip flex/grid item
+    // style fixup.
+    flags |= eSkipParentDisplayBasedStyleFixup;
+  }
+
+  return GetContext(aParentContext, ruleNode, visitedRuleNode,
+                    nsCSSPseudoElements::GetPseudoAtom(aType), aType,
+                    aParentElement, flags);
+}
+
+already_AddRefed<nsStyleContext>
+nsStyleSet::ProbePseudoElementStyle(Element* aParentElement,
+                                    CSSPseudoElementType aType,
+                                    nsStyleContext* aParentContext)
+{
+  TreeMatchContext treeContext(true, nsRuleWalker::eRelevantLinkUnvisited,
+                               aParentElement->OwnerDoc());
+  InitStyleScopes(treeContext, aParentElement);
+  return ProbePseudoElementStyle(aParentElement, aType, aParentContext,
+                                 treeContext);
+}
+
+already_AddRefed<nsStyleContext>
+nsStyleSet::ProbePseudoElementStyle(Element* aParentElement,
+                                    CSSPseudoElementType aType,
+                                    nsStyleContext* aParentContext,
+                                    TreeMatchContext& aTreeMatchContext,
+                                    Element* aPseudoElement)
+{
+  NS_ENSURE_FALSE(mInShutdown, nullptr);
+
+  NS_ASSERTION(aType < CSSPseudoElementType::Count,
+               "must have pseudo element type");
+  NS_ASSERTION(aParentElement, "aParentElement must not be null");
+
+  nsIAtom* pseudoTag = nsCSSPseudoElements::GetPseudoAtom(aType);
+  nsRuleWalker ruleWalker(mRuleTree, mAuthorStyleDisabled);
+  aTreeMatchContext.ResetForUnvisitedMatching();
+  PseudoElementRuleProcessorData data(PresContext(), aParentElement,
+                                      &ruleWalker, aType, aTreeMatchContext,
+                                      aPseudoElement);
+  WalkRestrictionRule(aType, &ruleWalker);
+  // not the root if there was a restriction rule
+  nsRuleNode *adjustedRoot = ruleWalker.CurrentNode();
+  FileRules(EnumRulesMatching<PseudoElementRuleProcessorData>, &data,
+            aParentElement, &ruleWalker);
+
+  nsRuleNode *ruleNode = ruleWalker.CurrentNode();
+  if (ruleNode == adjustedRoot) {
+    return nullptr;
+  }
+
+  nsRuleNode *visitedRuleNode = nullptr;
+
+  if (aTreeMatchContext.HaveRelevantLink()) {
+    aTreeMatchContext.ResetForVisitedMatching();
+    ruleWalker.Reset();
+    WalkRestrictionRule(aType, &ruleWalker);
+    FileRules(EnumRulesMatching<PseudoElementRuleProcessorData>, &data,
+              aParentElement, &ruleWalker);
+    visitedRuleNode = ruleWalker.CurrentNode();
+  }
+
+  // For pseudos, |data.IsLink()| being true means that
+  // our parent node is a link.
+  uint32_t flags = eNoFlags;
+  if (aType == CSSPseudoElementType::before ||
+      aType == CSSPseudoElementType::after) {
+    flags |= eDoAnimation;
+  } else {
+    // Flex and grid containers don't expect to have any pseudo-element children
+    // aside from ::before and ::after.  So if we have such a child, we're not
+    // actually in a flex/grid container, and we should skip flex/grid item
+    // style fixup.
+    flags |= eSkipParentDisplayBasedStyleFixup;
+  }
+
+  RefPtr<nsStyleContext> result =
+    GetContext(aParentContext, ruleNode, visitedRuleNode,
+               pseudoTag, aType,
+               aParentElement, flags);
+
+  // For :before and :after pseudo-elements, having display: none or no
+  // 'content' property is equivalent to not having the pseudo-element
+  // at all.
+  if (result &&
+      (pseudoTag == nsCSSPseudoElements::before ||
+       pseudoTag == nsCSSPseudoElements::after)) {
+    const nsStyleDisplay *display = result->StyleDisplay();
+    const nsStyleContent *content = result->StyleContent();
+    // XXXldb What is contentCount for |content: ""|?
+    if (display->mDisplay == StyleDisplay::None ||
+        content->ContentCount() == 0) {
+      result = nullptr;
+    }
+  }
+
+  return result.forget();
+}
+
+already_AddRefed<nsStyleContext>
+nsStyleSet::ResolveAnonymousBoxStyle(nsIAtom* aPseudoTag,
+                                     nsStyleContext* aParentContext,
+                                     uint32_t aFlags)
+{
+  NS_ENSURE_FALSE(mInShutdown, nullptr);
+
+#ifdef DEBUG
+    bool isAnonBox = nsCSSAnonBoxes::IsAnonBox(aPseudoTag)
+#ifdef MOZ_XUL
+                 && !nsCSSAnonBoxes::IsTreePseudoElement(aPseudoTag)
+#endif
+      ;
+    NS_PRECONDITION(isAnonBox, "Unexpected pseudo");
+#endif
+
+  nsRuleWalker ruleWalker(mRuleTree, mAuthorStyleDisabled);
+  AnonBoxRuleProcessorData data(PresContext(), aPseudoTag, &ruleWalker);
+  FileRules(EnumRulesMatching<AnonBoxRuleProcessorData>, &data, nullptr,
+            &ruleWalker);
+
+  if (aPseudoTag == nsCSSAnonBoxes::pageContent) {
+    // Add any @page rules that are specified.
+    nsTArray<nsCSSPageRule*> rules;
+    nsTArray<css::ImportantStyleData*> importantRules;
+    AppendPageRules(rules);
+    for (uint32_t i = 0, i_end = rules.Length(); i != i_end; ++i) {
+      css::Declaration* declaration = rules[i]->Declaration();
+      declaration->SetImmutable();
+      ruleWalker.Forward(declaration);
+      css::ImportantStyleData* importantRule =
+        declaration->GetImportantStyleData();
+      if (importantRule) {
+        importantRules.AppendElement(importantRule);
+      }
+    }
+    for (uint32_t i = 0, i_end = importantRules.Length(); i != i_end; ++i) {
+      ruleWalker.Forward(importantRules[i]);
+    }
+  }
+
+  return GetContext(aParentContext, ruleWalker.CurrentNode(), nullptr,
+                    aPseudoTag, CSSPseudoElementType::AnonBox,
+                    nullptr, aFlags);
+}
+
+#ifdef MOZ_XUL
+already_AddRefed<nsStyleContext>
+nsStyleSet::ResolveXULTreePseudoStyle(Element* aParentElement,
+                                      nsIAtom* aPseudoTag,
+                                      nsStyleContext* aParentContext,
+                                      nsICSSPseudoComparator* aComparator)
+{
+  NS_ENSURE_FALSE(mInShutdown, nullptr);
+
+  NS_ASSERTION(aPseudoTag, "must have pseudo tag");
+  NS_ASSERTION(nsCSSAnonBoxes::IsTreePseudoElement(aPseudoTag),
+               "Unexpected pseudo");
+
+  nsRuleWalker ruleWalker(mRuleTree, mAuthorStyleDisabled);
+  TreeMatchContext treeContext(true, nsRuleWalker::eRelevantLinkUnvisited,
+                               aParentElement->OwnerDoc());
+  InitStyleScopes(treeContext, aParentElement);
+  XULTreeRuleProcessorData data(PresContext(), aParentElement, &ruleWalker,
+                                aPseudoTag, aComparator, treeContext);
+  FileRules(EnumRulesMatching<XULTreeRuleProcessorData>, &data, aParentElement,
+            &ruleWalker);
+
+  nsRuleNode *ruleNode = ruleWalker.CurrentNode();
+  nsRuleNode *visitedRuleNode = nullptr;
+
+  if (treeContext.HaveRelevantLink()) {
+    treeContext.ResetForVisitedMatching();
+    ruleWalker.Reset();
+    FileRules(EnumRulesMatching<XULTreeRuleProcessorData>, &data,
+              aParentElement, &ruleWalker);
+    visitedRuleNode = ruleWalker.CurrentNode();
+  }
+
+  return GetContext(aParentContext, ruleNode, visitedRuleNode,
+                    // For pseudos, |data.IsLink()| being true means that
+                    // our parent node is a link.
+                    aPseudoTag, CSSPseudoElementType::XULTree,
+                    nullptr, eNoFlags);
+}
+#endif
+
+bool
+nsStyleSet::AppendFontFaceRules(nsTArray<nsFontFaceRuleContainer>& aArray)
+{
+  NS_ENSURE_FALSE(mInShutdown, false);
+  NS_ASSERTION(mBatching == 0, "rule processors out of date");
+
+  nsPresContext* presContext = PresContext();
+  for (uint32_t i = 0; i < ArrayLength(gCSSSheetTypes); ++i) {
+    if (gCSSSheetTypes[i] == SheetType::ScopedDoc)
+      continue;
+    nsCSSRuleProcessor *ruleProc = static_cast<nsCSSRuleProcessor*>
+                                    (mRuleProcessors[gCSSSheetTypes[i]].get());
+    if (ruleProc && !ruleProc->AppendFontFaceRules(presContext, aArray))
+      return false;
+  }
+  return true;
+}
+
+nsCSSKeyframesRule*
+nsStyleSet::KeyframesRuleForName(const nsString& aName)
+{
+  NS_ENSURE_FALSE(mInShutdown, nullptr);
+  NS_ASSERTION(mBatching == 0, "rule processors out of date");
+
+  nsPresContext* presContext = PresContext();
+  for (uint32_t i = ArrayLength(gCSSSheetTypes); i-- != 0; ) {
+    if (gCSSSheetTypes[i] == SheetType::ScopedDoc)
+      continue;
+    nsCSSRuleProcessor *ruleProc = static_cast<nsCSSRuleProcessor*>
+                                    (mRuleProcessors[gCSSSheetTypes[i]].get());
+    if (!ruleProc)
+      continue;
+    nsCSSKeyframesRule* result =
+      ruleProc->KeyframesRuleForName(presContext, aName);
+    if (result)
+      return result;
+  }
+  return nullptr;
+}
+
+nsCSSCounterStyleRule*
+nsStyleSet::CounterStyleRuleForName(const nsAString& aName)
+{
+  NS_ENSURE_FALSE(mInShutdown, nullptr);
+  NS_ASSERTION(mBatching == 0, "rule processors out of date");
+
+  nsPresContext* presContext = PresContext();
+  for (uint32_t i = ArrayLength(gCSSSheetTypes); i-- != 0; ) {
+    if (gCSSSheetTypes[i] == SheetType::ScopedDoc)
+      continue;
+    nsCSSRuleProcessor *ruleProc = static_cast<nsCSSRuleProcessor*>
+                                    (mRuleProcessors[gCSSSheetTypes[i]].get());
+    if (!ruleProc)
+      continue;
+    nsCSSCounterStyleRule *result =
+      ruleProc->CounterStyleRuleForName(presContext, aName);
+    if (result)
+      return result;
+  }
+  return nullptr;
+}
+
+bool
+nsStyleSet::AppendFontFeatureValuesRules(
+                                 nsTArray<nsCSSFontFeatureValuesRule*>& aArray)
+{
+  NS_ENSURE_FALSE(mInShutdown, false);
+  NS_ASSERTION(mBatching == 0, "rule processors out of date");
+
+  nsPresContext* presContext = PresContext();
+  for (uint32_t i = 0; i < ArrayLength(gCSSSheetTypes); ++i) {
+    nsCSSRuleProcessor *ruleProc = static_cast<nsCSSRuleProcessor*>
+                                    (mRuleProcessors[gCSSSheetTypes[i]].get());
+    if (ruleProc &&
+        !ruleProc->AppendFontFeatureValuesRules(presContext, aArray))
+    {
+      return false;
+    }
+  }
+  return true;
+}
+
+already_AddRefed<gfxFontFeatureValueSet>
+nsStyleSet::GetFontFeatureValuesLookup()
+{
+  if (mInitFontFeatureValuesLookup) {
+    mInitFontFeatureValuesLookup = false;
+
+    nsTArray<nsCSSFontFeatureValuesRule*> rules;
+    AppendFontFeatureValuesRules(rules);
+
+    mFontFeatureValuesLookup = new gfxFontFeatureValueSet();
+
+    uint32_t i, numRules = rules.Length();
+    for (i = 0; i < numRules; i++) {
+      nsCSSFontFeatureValuesRule *rule = rules[i];
+
+      const nsTArray<FontFamilyName>& familyList = rule->GetFamilyList().GetFontlist();
+      const nsTArray<gfxFontFeatureValueSet::FeatureValues>&
+        featureValues = rule->GetFeatureValues();
+
+      // for each family
+      size_t f, numFam;
+
+      numFam = familyList.Length();
+      for (f = 0; f < numFam; f++) {
+        mFontFeatureValuesLookup->AddFontFeatureValues(familyList[f].mName,
+                                                       featureValues);
+      }
+    }
+  }
+
+  RefPtr<gfxFontFeatureValueSet> lookup = mFontFeatureValuesLookup;
+  return lookup.forget();
+}
+
+bool
+nsStyleSet::AppendPageRules(nsTArray<nsCSSPageRule*>& aArray)
+{
+  NS_ENSURE_FALSE(mInShutdown, false);
+  NS_ASSERTION(mBatching == 0, "rule processors out of date");
+
+  nsPresContext* presContext = PresContext();
+  for (uint32_t i = 0; i < ArrayLength(gCSSSheetTypes); ++i) {
+    if (gCSSSheetTypes[i] == SheetType::ScopedDoc)
+      continue;
+    nsCSSRuleProcessor* ruleProc = static_cast<nsCSSRuleProcessor*>
+                                    (mRuleProcessors[gCSSSheetTypes[i]].get());
+    if (ruleProc && !ruleProc->AppendPageRules(presContext, aArray))
+      return false;
+  }
+  return true;
+}
+
+void
+nsStyleSet::BeginShutdown()
+{
+  mInShutdown = 1;
+}
+
+void
+nsStyleSet::Shutdown()
+{
+  mRuleTree = nullptr;
+  GCRuleTrees();
+  MOZ_ASSERT(mUnusedRuleNodeList.isEmpty());
+  MOZ_ASSERT(mUnusedRuleNodeCount == 0);
+}
+
+
+void
+nsStyleSet::GCRuleTrees()
+{
+  MOZ_ASSERT(!mInReconstruct);
+  MOZ_ASSERT(!mInGC);
+  mInGC = true;
+
+  while (!mUnusedRuleNodeList.isEmpty()) {
+    nsRuleNode* node = mUnusedRuleNodeList.popFirst();
+#ifdef DEBUG
+    if (node == mOldRootNode) {
+      // Flag that we've GCed the old root, if any.
+      mOldRootNode = nullptr;
+    }
+#endif
+    node->Destroy();
+  }
+
+#ifdef DEBUG
+  NS_ASSERTION(!mOldRootNode, "Should have GCed old root node");
+  mOldRootNode = nullptr;
+#endif
+  mUnusedRuleNodeCount = 0;
+  mInGC = false;
+}
+
+already_AddRefed<nsStyleContext>
+nsStyleSet::ReparentStyleContext(nsStyleContext* aStyleContext,
+                                 nsStyleContext* aNewParentContext,
+                                 Element* aElement)
+{
+  MOZ_ASSERT(aStyleContext, "aStyleContext must not be null");
+
+  // This short-circuit is OK because we don't call TryInitatingTransition
+  // during style reresolution if the style context pointer hasn't changed.
+  if (aStyleContext->GetParent() == aNewParentContext) {
+    RefPtr<nsStyleContext> ret = aStyleContext;
+    return ret.forget();
+  }
+
+  nsIAtom* pseudoTag = aStyleContext->GetPseudo();
+  CSSPseudoElementType pseudoType = aStyleContext->GetPseudoType();
+  nsRuleNode* ruleNode = aStyleContext->RuleNode();
+
+  MOZ_ASSERT(PresContext()->RestyleManager()->IsGecko(),
+             "stylo: the style set and restyle manager must have the same "
+             "StyleBackendType");
+  NS_ASSERTION(!PresContext()->RestyleManager()->AsGecko()->SkipAnimationRules(),
+               "we no longer handle SkipAnimationRules()");
+
+  nsRuleNode* visitedRuleNode = nullptr;
+  nsStyleContext* visitedContext = aStyleContext->GetStyleIfVisited();
+  // Reparenting a style context just changes where we inherit from,
+  // not what rules we match or what our DOM looks like.  In
+  // particular, it doesn't change whether this is a style context for
+  // a link.
+  if (visitedContext) {
+    visitedRuleNode = visitedContext->RuleNode();
+  }
+
+  uint32_t flags = eNoFlags;
+  if (aStyleContext->IsLinkContext()) {
+    flags |= eIsLink;
+
+    // GetContext handles propagating RelevantLinkVisited state from the
+    // parent in non-link cases; all we need to pass in is if this link
+    // is visited.
+    if (aStyleContext->RelevantLinkVisited()) {
+      flags |= eIsVisitedLink;
+    }
+  }
+
+  if (pseudoType == CSSPseudoElementType::NotPseudo ||
+      pseudoType == CSSPseudoElementType::before ||
+      pseudoType == CSSPseudoElementType::after) {
+    flags |= eDoAnimation;
+  }
+
+  if (aElement && aElement->IsRootOfAnonymousSubtree()) {
+    // For anonymous subtree roots, don't tweak "display" value based on whether
+    // or not the parent is styled as a flex/grid container. (If the parent
+    // has anonymous-subtree kids, then we know it's not actually going to get
+    // a flex/grid container frame, anyway.)
+    flags |= eSkipParentDisplayBasedStyleFixup;
+  }
+
+  return GetContext(aNewParentContext, ruleNode, visitedRuleNode,
+                    pseudoTag, pseudoType,
+                    aElement, flags);
+}
+
+struct MOZ_STACK_CLASS StatefulData : public StateRuleProcessorData {
+  StatefulData(nsPresContext* aPresContext, Element* aElement,
+               EventStates aStateMask, TreeMatchContext& aTreeMatchContext)
+    : StateRuleProcessorData(aPresContext, aElement, aStateMask,
+                             aTreeMatchContext),
+      mHint(nsRestyleHint(0))
+  {}
+  nsRestyleHint   mHint;
+};
+
+struct MOZ_STACK_CLASS StatefulPseudoElementData : public PseudoElementStateRuleProcessorData {
+  StatefulPseudoElementData(nsPresContext* aPresContext, Element* aElement,
+               EventStates aStateMask, CSSPseudoElementType aPseudoType,
+               TreeMatchContext& aTreeMatchContext, Element* aPseudoElement)
+    : PseudoElementStateRuleProcessorData(aPresContext, aElement, aStateMask,
+                                          aPseudoType, aTreeMatchContext,
+                                          aPseudoElement),
+      mHint(nsRestyleHint(0))
+  {}
+  nsRestyleHint   mHint;
+};
+
+static bool SheetHasDocumentStateStyle(nsIStyleRuleProcessor* aProcessor,
+                                         void *aData)
+{
+  StatefulData* data = (StatefulData*)aData;
+  if (aProcessor->HasDocumentStateDependentStyle(data)) {
+    data->mHint = eRestyle_Self;
+    return false; // don't continue
+  }
+  return true; // continue
+}
+
+// Test if style is dependent on a document state.
+bool
+nsStyleSet::HasDocumentStateDependentStyle(nsIContent*    aContent,
+                                           EventStates    aStateMask)
+{
+  if (!aContent || !aContent->IsElement())
+    return false;
+
+  TreeMatchContext treeContext(false, nsRuleWalker::eLinksVisitedOrUnvisited,
+                               aContent->OwnerDoc());
+  InitStyleScopes(treeContext, aContent->AsElement());
+  StatefulData data(PresContext(), aContent->AsElement(), aStateMask,
+                    treeContext);
+  WalkRuleProcessors(SheetHasDocumentStateStyle, &data, true);
+  return data.mHint != 0;
+}
+
+static bool SheetHasStatefulStyle(nsIStyleRuleProcessor* aProcessor,
+                                    void *aData)
+{
+  StatefulData* data = (StatefulData*)aData;
+  nsRestyleHint hint = aProcessor->HasStateDependentStyle(data);
+  data->mHint = nsRestyleHint(data->mHint | hint);
+  return true; // continue
+}
+
+static bool SheetHasStatefulPseudoElementStyle(nsIStyleRuleProcessor* aProcessor,
+                                               void *aData)
+{
+  StatefulPseudoElementData* data = (StatefulPseudoElementData*)aData;
+  nsRestyleHint hint = aProcessor->HasStateDependentStyle(data);
+  data->mHint = nsRestyleHint(data->mHint | hint);
+  return true; // continue
+}
+
+// Test if style is dependent on content state
+nsRestyleHint
+nsStyleSet::HasStateDependentStyle(Element*             aElement,
+                                   EventStates          aStateMask)
+{
+  TreeMatchContext treeContext(false, nsRuleWalker::eLinksVisitedOrUnvisited,
+                               aElement->OwnerDoc());
+  InitStyleScopes(treeContext, aElement);
+  StatefulData data(PresContext(), aElement, aStateMask, treeContext);
+  WalkRuleProcessors(SheetHasStatefulStyle, &data, false);
+  return data.mHint;
+}
+
+nsRestyleHint
+nsStyleSet::HasStateDependentStyle(Element* aElement,
+                                   CSSPseudoElementType aPseudoType,
+                                   Element* aPseudoElement,
+                                   EventStates aStateMask)
+{
+  TreeMatchContext treeContext(false, nsRuleWalker::eLinksVisitedOrUnvisited,
+                               aElement->OwnerDoc());
+  InitStyleScopes(treeContext, aElement);
+  StatefulPseudoElementData data(PresContext(), aElement, aStateMask,
+                                 aPseudoType, treeContext, aPseudoElement);
+  WalkRuleProcessors(SheetHasStatefulPseudoElementStyle, &data, false);
+  return data.mHint;
+}
+
+struct MOZ_STACK_CLASS AttributeData : public AttributeRuleProcessorData {
+  AttributeData(nsPresContext* aPresContext, Element* aElement,
+                int32_t aNameSpaceID, nsIAtom* aAttribute, int32_t aModType,
+                bool aAttrHasChanged, const nsAttrValue* aOtherValue,
+                TreeMatchContext& aTreeMatchContext)
+    : AttributeRuleProcessorData(aPresContext, aElement, aNameSpaceID,
+                                 aAttribute, aModType, aAttrHasChanged,
+                                 aOtherValue, aTreeMatchContext),
+      mHint(nsRestyleHint(0))
+  {}
+  nsRestyleHint mHint;
+  RestyleHintData mHintData;
+};
+
+static bool
+SheetHasAttributeStyle(nsIStyleRuleProcessor* aProcessor, void *aData)
+{
+  AttributeData* data = (AttributeData*)aData;
+  nsRestyleHint hint =
+    aProcessor->HasAttributeDependentStyle(data, data->mHintData);
+  data->mHint = nsRestyleHint(data->mHint | hint);
+  return true; // continue
+}
+
+// Test if style is dependent on content state
+nsRestyleHint
+nsStyleSet::HasAttributeDependentStyle(Element*       aElement,
+                                       int32_t        aNameSpaceID,
+                                       nsIAtom*       aAttribute,
+                                       int32_t        aModType,
+                                       bool           aAttrHasChanged,
+                                       const nsAttrValue* aOtherValue,
+                                       mozilla::RestyleHintData&
+                                         aRestyleHintDataResult)
+{
+  TreeMatchContext treeContext(false, nsRuleWalker::eLinksVisitedOrUnvisited,
+                               aElement->OwnerDoc());
+  InitStyleScopes(treeContext, aElement);
+  AttributeData data(PresContext(), aElement, aNameSpaceID, aAttribute,
+                     aModType, aAttrHasChanged, aOtherValue, treeContext);
+  WalkRuleProcessors(SheetHasAttributeStyle, &data, false);
+  if (!(data.mHint & eRestyle_Subtree)) {
+    // No point keeping the list of selectors around if we are going to
+    // restyle the whole subtree unconditionally.
+    aRestyleHintDataResult = Move(data.mHintData);
+  }
+  return data.mHint;
+}
+
+bool
+nsStyleSet::MediumFeaturesChanged()
+{
+  NS_ASSERTION(mBatching == 0, "rule processors out of date");
+
+  // We can't use WalkRuleProcessors without a content node.
+  nsPresContext* presContext = PresContext();
+  bool stylesChanged = false;
+  for (nsIStyleRuleProcessor* processor : mRuleProcessors) {
+    if (!processor) {
+      continue;
+    }
+    bool thisChanged = processor->MediumFeaturesChanged(presContext);
+    stylesChanged = stylesChanged || thisChanged;
+  }
+  for (nsIStyleRuleProcessor* processor : mScopedDocSheetRuleProcessors) {
+    bool thisChanged = processor->MediumFeaturesChanged(presContext);
+    stylesChanged = stylesChanged || thisChanged;
+  }
+
+  if (mBindingManager) {
+    bool thisChanged = false;
+    mBindingManager->MediumFeaturesChanged(presContext, &thisChanged);
+    stylesChanged = stylesChanged || thisChanged;
+  }
+
+  return stylesChanged;
+}
+
+bool
+nsStyleSet::EnsureUniqueInnerOnCSSSheets()
+{
+  AutoTArray<CSSStyleSheet*, 32> queue;
+  for (SheetType type : gCSSSheetTypes) {
+    for (CSSStyleSheet* sheet : mSheets[type]) {
+      queue.AppendElement(sheet);
+    }
+  }
+
+  if (mBindingManager) {
+    AutoTArray<StyleSheet*, 32> sheets;
+    // XXXheycam stylo: AppendAllSheets will need to be able to return either
+    // CSSStyleSheets or ServoStyleSheets, on request (and then here requesting
+    // CSSStyleSheets).
+    mBindingManager->AppendAllSheets(sheets);
+    for (StyleSheet* sheet : sheets) {
+      MOZ_ASSERT(sheet->IsGecko(), "stylo: AppendAllSheets shouldn't give us "
+                                   "ServoStyleSheets yet");
+      queue.AppendElement(sheet->AsGecko());
+    }
+  }
+
+  while (!queue.IsEmpty()) {
+    uint32_t idx = queue.Length() - 1;
+    CSSStyleSheet* sheet = queue[idx];
+    queue.RemoveElementAt(idx);
+
+    sheet->EnsureUniqueInner();
+
+    // Enqueue all the sheet's children.
+    sheet->AppendAllChildSheets(queue);
+  }
+
+  bool res = mNeedsRestyleAfterEnsureUniqueInner;
+  mNeedsRestyleAfterEnsureUniqueInner = false;
+  return res;
+}
+
+nsIStyleRule*
+nsStyleSet::InitialStyleRule()
+{
+  if (!mInitialStyleRule) {
+    mInitialStyleRule = new nsInitialStyleRule;
+  }
+  return mInitialStyleRule;
+}
+
+bool
+nsStyleSet::HasRuleProcessorUsedByMultipleStyleSets(SheetType aSheetType)
+{
+  MOZ_ASSERT(size_t(aSheetType) < ArrayLength(mRuleProcessors));
+  if (!IsCSSSheetType(aSheetType) || !mRuleProcessors[aSheetType]) {
+    return false;
+  }
+  nsCSSRuleProcessor* rp =
+    static_cast<nsCSSRuleProcessor*>(mRuleProcessors[aSheetType].get());
+  return rp->IsUsedByMultipleStyleSets();
+}
+
+void
+nsStyleSet::ClearSelectors()
+{
+  // We might be called before we've done our first rule tree construction.
+  if (!mRuleTree) {
+    return;
+  }
+  MOZ_ASSERT(PresContext()->RestyleManager()->IsGecko(),
+             "stylo: the style set and restyle manager must have the same "
+             "StyleBackendType");
+  PresContext()->RestyleManager()->AsGecko()->ClearSelectors();
+}