Add m-esr52 at 52.6.0

1 files changed, 1090 insertions, 0 deletions

diff --git a/layout/style/nsRuleNode.h b/layout/style/nsRuleNode.h
new file mode 100644
index 000000000..f9e71618b
--- /dev/null
+++ b/layout/style/nsRuleNode.h
@@ -0,0 +1,1090 @@
+/* -*- 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/. */
+
+/*
+ * a node in the lexicographic tree of rules that match an element,
+ * responsible for converting the rules' information into computed style
+ */
+
+#ifndef nsRuleNode_h___
+#define nsRuleNode_h___
+
+#include "mozilla/ArenaObjectID.h"
+#include "mozilla/LinkedList.h"
+#include "mozilla/PodOperations.h"
+#include "mozilla/RangedArray.h"
+#include "mozilla/RuleNodeCacheConditions.h"
+#include "mozilla/SheetType.h"
+#include "nsPresContext.h"
+#include "nsStyleStruct.h"
+
+class nsCSSPropertyIDSet;
+class nsCSSValue;
+class nsIStyleRule;
+class nsStyleContext;
+class nsStyleCoord;
+struct nsCSSRect;
+struct nsCSSValueList;
+struct nsCSSValuePairList;
+struct nsRuleData;
+
+struct nsInheritedStyleData
+{
+  mozilla::RangedArray<void*,
+                       nsStyleStructID_Inherited_Start,
+                       nsStyleStructID_Inherited_Count> mStyleStructs;
+
+  void* operator new(size_t sz, nsPresContext* aContext) {
+    return aContext->PresShell()->
+      AllocateByObjectID(mozilla::eArenaObjectID_nsInheritedStyleData, sz);
+  }
+
+  void DestroyStructs(uint64_t aBits, nsPresContext* aContext) {
+#define STYLE_STRUCT_INHERITED(name, checkdata_cb) \
+    void *name##Data = mStyleStructs[eStyleStruct_##name]; \
+    if (name##Data && !(aBits & NS_STYLE_INHERIT_BIT(name))) \
+      static_cast<nsStyle##name*>(name##Data)->Destroy(aContext);
+#define STYLE_STRUCT_RESET(name, checkdata_cb)
+
+#include "nsStyleStructList.h"
+
+#undef STYLE_STRUCT_INHERITED
+#undef STYLE_STRUCT_RESET
+  }
+
+  void Destroy(uint64_t aBits, nsPresContext* aContext) {
+    DestroyStructs(aBits, aContext);
+    aContext->PresShell()->
+      FreeByObjectID(mozilla::eArenaObjectID_nsInheritedStyleData, this);
+  }
+
+  nsInheritedStyleData() {
+    for (nsStyleStructID i = nsStyleStructID_Inherited_Start;
+         i < nsStyleStructID_Inherited_Start + nsStyleStructID_Inherited_Count;
+         i = nsStyleStructID(i + 1)) {
+      mStyleStructs[i] = nullptr;
+    }
+  }
+};
+
+struct nsResetStyleData
+{
+  mozilla::RangedArray<void*,
+                       nsStyleStructID_Reset_Start,
+                       nsStyleStructID_Reset_Count> mStyleStructs;
+
+  nsResetStyleData()
+  {
+    for (nsStyleStructID i = nsStyleStructID_Reset_Start;
+         i < nsStyleStructID_Reset_Start + nsStyleStructID_Reset_Count;
+         i = nsStyleStructID(i + 1)) {
+      mStyleStructs[i] = nullptr;
+    }
+  }
+
+  void* operator new(size_t sz, nsPresContext* aContext) {
+    return aContext->PresShell()->
+      AllocateByObjectID(mozilla::eArenaObjectID_nsResetStyleData, sz);
+  }
+
+  void Destroy(uint64_t aBits, nsPresContext* aContext) {
+#define STYLE_STRUCT_RESET(name, checkdata_cb) \
+    void *name##Data = mStyleStructs[eStyleStruct_##name]; \
+    if (name##Data && !(aBits & NS_STYLE_INHERIT_BIT(name))) \
+      static_cast<nsStyle##name*>(name##Data)->Destroy(aContext);
+#define STYLE_STRUCT_INHERITED(name, checkdata_cb)
+
+#include "nsStyleStructList.h"
+
+#undef STYLE_STRUCT_RESET
+#undef STYLE_STRUCT_INHERITED
+
+    aContext->PresShell()->
+      FreeByObjectID(mozilla::eArenaObjectID_nsResetStyleData, this);
+  }
+};
+
+struct nsConditionalResetStyleData
+{
+  static uint32_t GetBitForSID(const nsStyleStructID aSID) {
+    return 1 << aSID;
+  }
+
+  struct Entry
+  {
+    Entry(const mozilla::RuleNodeCacheConditions& aConditions,
+          void* aStyleStruct,
+          Entry* aNext)
+      : mConditions(aConditions), mStyleStruct(aStyleStruct), mNext(aNext) {}
+
+    void* operator new(size_t sz, nsPresContext* aContext) {
+      return aContext->PresShell()->AllocateByObjectID(
+          mozilla::eArenaObjectID_nsConditionalResetStyleDataEntry, sz);
+    }
+
+    const mozilla::RuleNodeCacheConditions mConditions;
+    void* const mStyleStruct;
+    Entry* const mNext;
+  };
+
+  // Each entry is either a pointer to a style struct or a
+  // pointer to an Entry object.  A bit in mConditionalBits
+  // means that it is an Entry.
+  mozilla::RangedArray<void*,
+                       nsStyleStructID_Reset_Start,
+                       nsStyleStructID_Reset_Count> mEntries;
+
+  uint32_t mConditionalBits;
+
+  nsConditionalResetStyleData()
+  {
+    for (nsStyleStructID i = nsStyleStructID_Reset_Start;
+         i < nsStyleStructID_Reset_Start + nsStyleStructID_Reset_Count;
+         i = nsStyleStructID(i + 1)) {
+      mEntries[i] = nullptr;
+    }
+    mConditionalBits = 0;
+  }
+
+  void* operator new(size_t sz, nsPresContext* aContext) {
+    return aContext->PresShell()->AllocateByObjectID(
+        mozilla::eArenaObjectID_nsConditionalResetStyleData, sz);
+  }
+
+  void* GetStyleData(nsStyleStructID aSID) const {
+    if (mConditionalBits & GetBitForSID(aSID)) {
+      return nullptr;
+    }
+    return mEntries[aSID];
+  }
+
+  void* GetStyleData(nsStyleStructID aSID,
+                     nsStyleContext* aStyleContext,
+                     bool aCanComputeData) const {
+    if (!(mConditionalBits & GetBitForSID(aSID))) {
+      return mEntries[aSID];
+    }
+    if (!aCanComputeData) {
+      // If aCanComputeData is false, then any previously-computed data
+      // would have been cached on the style context.  Therefore it's
+      // unnecessary to check the conditional data.  It's also
+      // incorrect, because calling e->mConditions.Matches() below could
+      // cause additional structs to be computed, which is incorrect
+      // during CalcStyleDifference.
+      return nullptr;
+    }
+    return GetConditionalStyleData(aSID, aStyleContext);
+  }
+
+private:
+  // non-inline helper for GetStyleData
+  void* GetConditionalStyleData(nsStyleStructID aSID,
+                                nsStyleContext* aStyleContext) const;
+
+public:
+  void SetStyleData(nsStyleStructID aSID, void* aStyleStruct) {
+    MOZ_ASSERT(!(mConditionalBits & GetBitForSID(aSID)),
+               "rule node should not have unconditional and conditional style "
+               "data for a given struct");
+    mConditionalBits &= ~GetBitForSID(aSID);
+    mEntries[aSID] = aStyleStruct;
+  }
+
+  void SetStyleData(nsStyleStructID aSID,
+                    nsPresContext* aPresContext,
+                    void* aStyleStruct,
+                    const mozilla::RuleNodeCacheConditions& aConditions) {
+    if (!(mConditionalBits & GetBitForSID(aSID))) {
+      MOZ_ASSERT(!mEntries[aSID],
+                 "rule node should not have unconditional and conditional "
+                 "style data for a given struct");
+      mEntries[aSID] = nullptr;
+    }
+
+    MOZ_ASSERT(aConditions.CacheableWithDependencies(),
+               "don't call SetStyleData with a cache key that has no "
+               "conditions or is uncacheable");
+
+#ifdef DEBUG
+    for (Entry* e = static_cast<Entry*>(mEntries[aSID]); e; e = e->mNext) {
+      NS_WARNING_ASSERTION(e->mConditions != aConditions,
+                           "wasteful to have duplicate conditional style data");
+    }
+#endif
+
+    mConditionalBits |= GetBitForSID(aSID);
+    mEntries[aSID] =
+      new (aPresContext) Entry(aConditions, aStyleStruct,
+                               static_cast<Entry*>(mEntries[aSID]));
+  }
+
+  void Destroy(uint64_t aBits, nsPresContext* aContext) {
+#define STYLE_STRUCT_RESET(name, checkdata_cb)                                 \
+    void* name##Ptr = mEntries[eStyleStruct_##name];                           \
+    if (name##Ptr) {                                                           \
+      if (!(mConditionalBits & NS_STYLE_INHERIT_BIT(name))) {                  \
+        if (!(aBits & NS_STYLE_INHERIT_BIT(name))) {                           \
+          static_cast<nsStyle##name*>(name##Ptr)->Destroy(aContext);           \
+        }                                                                      \
+      } else {                                                                 \
+        Entry* e = static_cast<Entry*>(name##Ptr);                             \
+        MOZ_ASSERT(e, "if mConditionalBits bit is set, we must have at least " \
+                      "one conditional style struct");                         \
+        do {                                                                   \
+          static_cast<nsStyle##name*>(e->mStyleStruct)->Destroy(aContext);     \
+          Entry* next = e->mNext;                                              \
+          aContext->PresShell()->FreeByObjectID(                               \
+              mozilla::eArenaObjectID_nsConditionalResetStyleDataEntry, e);    \
+          e = next;                                                            \
+        } while (e);                                                           \
+      }                                                                        \
+    }
+#define STYLE_STRUCT_INHERITED(name, checkdata_cb)
+
+#include "nsStyleStructList.h"
+
+#undef STYLE_STRUCT_RESET
+#undef STYLE_STRUCT_INHERITED
+
+    aContext->PresShell()->FreeByObjectID(
+        mozilla::eArenaObjectID_nsConditionalResetStyleData, this);
+  }
+
+};
+
+struct nsCachedStyleData
+{
+  nsInheritedStyleData* mInheritedData;
+  nsConditionalResetStyleData* mResetData;
+
+  static bool IsReset(const nsStyleStructID aSID) {
+    MOZ_ASSERT(0 <= aSID && aSID < nsStyleStructID_Length,
+               "must be an inherited or reset SID");
+    return nsStyleStructID_Reset_Start <= aSID;
+  }
+
+  static bool IsInherited(const nsStyleStructID aSID) {
+    return !IsReset(aSID);
+  }
+
+  static uint32_t GetBitForSID(const nsStyleStructID aSID) {
+    return nsConditionalResetStyleData::GetBitForSID(aSID);
+  }
+
+  void* NS_FASTCALL GetStyleData(const nsStyleStructID aSID) {
+    if (IsReset(aSID)) {
+      if (mResetData) {
+        return mResetData->GetStyleData(aSID);
+      }
+    } else {
+      if (mInheritedData) {
+        return mInheritedData->mStyleStructs[aSID];
+      }
+    }
+    return nullptr;
+  }
+
+  void* NS_FASTCALL GetStyleData(const nsStyleStructID aSID,
+                                 nsStyleContext* aStyleContext,
+                                 bool aCanComputeData) {
+    if (IsReset(aSID)) {
+      if (mResetData) {
+        return mResetData->GetStyleData(aSID, aStyleContext, aCanComputeData);
+      }
+    } else {
+      if (mInheritedData) {
+        return mInheritedData->mStyleStructs[aSID];
+      }
+    }
+    return nullptr;
+  }
+
+  void NS_FASTCALL SetStyleData(const nsStyleStructID aSID,
+                                nsPresContext *aPresContext, void *aData) {
+    if (IsReset(aSID)) {
+      if (!mResetData) {
+        mResetData = new (aPresContext) nsConditionalResetStyleData;
+      }
+      mResetData->SetStyleData(aSID, aData);
+    } else {
+      if (!mInheritedData) {
+        mInheritedData = new (aPresContext) nsInheritedStyleData;
+      }
+      mInheritedData->mStyleStructs[aSID] = aData;
+    }
+  }
+
+  // Typesafe and faster versions of the above
+  #define STYLE_STRUCT_INHERITED(name_, checkdata_cb_)                         \
+    nsStyle##name_ * NS_FASTCALL GetStyle##name_ () {                          \
+      return mInheritedData ? static_cast<nsStyle##name_*>(                    \
+        mInheritedData->mStyleStructs[eStyleStruct_##name_]) : nullptr;        \
+    }
+  #define STYLE_STRUCT_RESET(name_, checkdata_cb_)                             \
+    nsStyle##name_ * NS_FASTCALL GetStyle##name_ (nsStyleContext* aContext,    \
+                                                  bool aCanComputeData) {      \
+      return mResetData ? static_cast<nsStyle##name_*>(                        \
+        mResetData->GetStyleData(eStyleStruct_##name_, aContext,               \
+                                 aCanComputeData))                             \
+                        : nullptr;                                             \
+    }
+  #include "nsStyleStructList.h"
+  #undef STYLE_STRUCT_RESET
+  #undef STYLE_STRUCT_INHERITED
+
+  void Destroy(uint64_t aBits, nsPresContext* aContext) {
+    if (mResetData)
+      mResetData->Destroy(aBits, aContext);
+    if (mInheritedData)
+      mInheritedData->Destroy(aBits, aContext);
+    mResetData = nullptr;
+    mInheritedData = nullptr;
+  }
+
+  nsCachedStyleData() :mInheritedData(nullptr), mResetData(nullptr) {}
+  ~nsCachedStyleData() {}
+};
+
+/**
+ * nsRuleNode is a node in a lexicographic tree (the "rule tree")
+ * indexed by style rules (implementations of nsIStyleRule).
+ *
+ * The rule tree is owned by the nsStyleSet and is destroyed when the
+ * presentation of the document goes away. Its entries are reference-
+ * counted, with strong references held by child nodes, style structs
+ * and (for the root), the style set. Rule nodes are not immediately
+ * destroyed when their reference-count drops to zero, but are instead
+ * destroyed during a GC sweep.
+ *
+ * An nsStyleContext, which represents the computed style data for an
+ * element, points to an nsRuleNode.  The path from the root of the rule
+ * tree to the nsStyleContext's mRuleNode gives the list of the rules
+ * matched, from least important in the cascading order to most
+ * important in the cascading order.
+ *
+ * The reason for using a lexicographic tree is that it allows for
+ * sharing of style data, which saves both memory (for storing the
+ * computed style data) and time (for computing them).  This sharing
+ * depends on the computed style data being stored in structs (nsStyle*)
+ * that contain only properties that are inherited by default
+ * ("inherited structs") or structs that contain only properties that
+ * are not inherited by default ("reset structs").  The optimization
+ * depends on the normal case being that style rules specify relatively
+ * few properties and even that elements generally have relatively few
+ * properties specified.  This allows sharing in the following ways:
+ *   1. [mainly reset structs] When a style data struct will contain the
+ *      same computed value for any elements that match the same set of
+ *      rules (common for reset structs), it can be stored on the
+ *      nsRuleNode instead of on the nsStyleContext.
+ *   2. [only? reset structs] When (1) occurs, and an nsRuleNode doesn't
+ *      have any rules that change the values in the struct, the
+ *      nsRuleNode can share that struct with its parent nsRuleNode.
+ *   3. [mainly inherited structs] When an element doesn't match any
+ *      rules that change the value of a property (or, in the edge case,
+ *      when all the values specified are 'inherit'), the nsStyleContext
+ *      can use the same nsStyle* struct as its parent nsStyleContext.
+ *
+ * Since the data represented by an nsIStyleRule are immutable, the data
+ * represented by an nsRuleNode are also immutable.
+ */
+
+enum nsFontSizeType {
+  eFontSize_HTML = 1,
+  eFontSize_CSS = 2
+};
+
+// Note: This LinkedListElement is used for storing unused nodes in the
+// linked list on nsStyleSet. We use mNextSibling for the singly-linked
+// sibling list.
+class nsRuleNode : public mozilla::LinkedListElement<nsRuleNode> {
+public:
+  enum RuleDetail {
+    eRuleNone, // No props have been specified at all.
+    eRulePartialReset, // At least one prop with a non-"inherit" value
+                       // has been specified.  No props have been
+                       // specified with an "inherit" value.  At least
+                       // one prop remains unspecified.
+    eRulePartialMixed, // At least one prop with a non-"inherit" value
+                       // has been specified.  Some props may also have
+                       // been specified with an "inherit" value.  At
+                       // least one prop remains unspecified.
+    eRulePartialInherited, // Only props with "inherit" values have
+                           // have been specified.  At least one prop
+                           // remains unspecified.
+    eRuleFullReset, // All props have been specified.  None has an
+                    // "inherit" value.
+    eRuleFullMixed, // All props have been specified.  At least one has
+                    // a non-"inherit" value.
+    eRuleFullInherited  // All props have been specified with "inherit"
+                        // values.
+  };
+
+private:
+  nsPresContext* const mPresContext; // Our pres context.
+
+  const RefPtr<nsRuleNode> mParent; // A pointer to the parent node in the tree.
+                                    // This enables us to walk backwards from the
+                                    // most specific rule matched to the least
+                                    // specific rule (which is the optimal order to
+                                    // use for lookups of style properties.
+
+  const nsCOMPtr<nsIStyleRule> mRule; // A pointer to our specific rule.
+
+  nsRuleNode* mNextSibling; // This value should be used only by the
+                            // parent, since the parent may store
+                            // children in a hash, which means this
+                            // pointer is not meaningful.  Order of
+                            // siblings is also not meaningful.
+
+  struct Key {
+    nsIStyleRule* mRule;
+    mozilla::SheetType mLevel;
+    bool mIsImportantRule;
+
+    Key(nsIStyleRule* aRule, mozilla::SheetType aLevel, bool aIsImportantRule)
+      : mRule(aRule), mLevel(aLevel), mIsImportantRule(aIsImportantRule)
+    {}
+
+    bool operator==(const Key& aOther) const
+    {
+      return mRule == aOther.mRule &&
+             mLevel == aOther.mLevel &&
+             mIsImportantRule == aOther.mIsImportantRule;
+    }
+
+    bool operator!=(const Key& aOther) const
+    {
+      return !(*this == aOther);
+    }
+  };
+
+  static PLDHashNumber
+  ChildrenHashHashKey(const void *aKey);
+
+  static bool
+  ChildrenHashMatchEntry(const PLDHashEntryHdr *aHdr, const void *aKey);
+
+  static const PLDHashTableOps ChildrenHashOps;
+
+  Key GetKey() const {
+    return Key(mRule, GetLevel(), IsImportantRule());
+  }
+
+  // The children of this node are stored in either a hashtable or list
+  // that maps from rules to our nsRuleNode children.  When matching
+  // rules, we use this mapping to transition from node to node
+  // (constructing new nodes as needed to flesh out the tree).
+
+  union {
+    void* asVoid;
+    nsRuleNode* asList;
+    PLDHashTable* asHash;
+  } mChildren; // Accessed only through the methods below.
+
+  enum {
+    kTypeMask = 0x1,
+    kListType = 0x0,
+    kHashType = 0x1
+  };
+  enum {
+    // Maximum to have in a list before converting to a hashtable.
+    // XXX Need to optimize this.
+    kMaxChildrenInList = 32
+  };
+
+  bool HaveChildren() const {
+    return mChildren.asVoid != nullptr;
+  }
+  bool ChildrenAreHashed() {
+    return (intptr_t(mChildren.asVoid) & kTypeMask) == kHashType;
+  }
+  nsRuleNode* ChildrenList() {
+    return mChildren.asList;
+  }
+  nsRuleNode** ChildrenListPtr() {
+    return &mChildren.asList;
+  }
+  PLDHashTable* ChildrenHash() {
+    return (PLDHashTable*) (intptr_t(mChildren.asHash) & ~intptr_t(kTypeMask));
+  }
+  void SetChildrenList(nsRuleNode *aList) {
+    NS_ASSERTION(!(intptr_t(aList) & kTypeMask),
+                 "pointer not 2-byte aligned");
+    mChildren.asList = aList;
+  }
+  void SetChildrenHash(PLDHashTable *aHashtable) {
+    NS_ASSERTION(!(intptr_t(aHashtable) & kTypeMask),
+                 "pointer not 2-byte aligned");
+    mChildren.asHash = (PLDHashTable*)(intptr_t(aHashtable) | kHashType);
+  }
+  void ConvertChildrenToHash(int32_t aNumKids);
+
+  void RemoveChild(nsRuleNode* aNode);
+
+  nsCachedStyleData mStyleData;   // Any data we cached on the rule node.
+
+  uint32_t mDependentBits; // Used to cache the fact that we can look up
+                           // cached data under a parent rule.
+
+  uint32_t mNoneBits; // Used to cache the fact that the branch to this
+                      // node specifies no non-inherited data for a
+                      // given struct type.  (This usually implies that
+                      // the entire branch specifies no non-inherited
+                      // data, although not necessarily, if a
+                      // non-inherited value is overridden by an
+                      // explicit 'inherit' value.)  For example, if an
+                      // entire rule branch specifies no color
+                      // information, then a bit will be set along every
+                      // rule node on that branch, so that you can break
+                      // out of the rule tree early and just inherit
+                      // from the parent style context.  The presence of
+                      // this bit means we should just get inherited
+                      // data from the parent style context, and it is
+                      // never used for reset structs since their
+                      // Compute*Data functions don't initialize from
+                      // inherited data.
+
+  // Reference count. Style contexts hold strong references to their rule node,
+  // and rule nodes hold strong references to their parent.
+  //
+  // When the refcount drops to zero, we don't necessarily free the node.
+  // Instead, we notify the style set, which performs periodic sweeps.
+  uint32_t mRefCnt;
+
+public:
+  // Infallible overloaded new operator that allocates from a presShell arena.
+  void* operator new(size_t sz, nsPresContext* aContext);
+  void Destroy();
+
+  // Implemented in nsStyleSet.h, since it needs to know about nsStyleSet.
+  inline void AddRef();
+
+  // Implemented in nsStyleSet.h, since it needs to know about nsStyleSet.
+  inline void Release();
+
+protected:
+  void PropagateDependentBit(nsStyleStructID aSID, nsRuleNode* aHighestNode,
+                             void* aStruct);
+  void PropagateNoneBit(uint32_t aBit, nsRuleNode* aHighestNode);
+  static void PropagateGrandancestorBit(nsStyleContext* aContext,
+                                        nsStyleContext* aContextInheritedFrom);
+
+  const void* SetDefaultOnRoot(const nsStyleStructID aSID,
+                               nsStyleContext* aContext);
+
+  /**
+   * Resolves any property values in aRuleData for a given style struct that
+   * have eCSSUnit_TokenStream values, by resolving them against the computed
+   * variable values on the style context and re-parsing the property.
+   *
+   * @return Whether any properties with eCSSUnit_TokenStream values were
+   *   encountered.
+   */
+  static bool ResolveVariableReferences(const nsStyleStructID aSID,
+                                        nsRuleData* aRuleData,
+                                        nsStyleContext* aContext);
+
+  const void*
+    WalkRuleTree(const nsStyleStructID aSID, nsStyleContext* aContext);
+
+  const void*
+    ComputeDisplayData(void* aStartStruct,
+                       const nsRuleData* aRuleData,
+                       nsStyleContext* aContext, nsRuleNode* aHighestNode,
+                       RuleDetail aRuleDetail,
+                       const mozilla::RuleNodeCacheConditions aConditions);
+
+  const void*
+    ComputeVisibilityData(void* aStartStruct,
+                          const nsRuleData* aRuleData,
+                          nsStyleContext* aContext, nsRuleNode* aHighestNode,
+                          RuleDetail aRuleDetail,
+                          const mozilla::RuleNodeCacheConditions aConditions);
+
+  const void*
+    ComputeFontData(void* aStartStruct,
+                    const nsRuleData* aRuleData,
+                    nsStyleContext* aContext, nsRuleNode* aHighestNode,
+                    RuleDetail aRuleDetail,
+                    const mozilla::RuleNodeCacheConditions aConditions);
+
+  const void*
+    ComputeColorData(void* aStartStruct,
+                     const nsRuleData* aRuleData,
+                     nsStyleContext* aContext, nsRuleNode* aHighestNode,
+                     RuleDetail aRuleDetail,
+                     const mozilla::RuleNodeCacheConditions aConditions);
+
+  const void*
+    ComputeBackgroundData(void* aStartStruct,
+                          const nsRuleData* aRuleData,
+                          nsStyleContext* aContext, nsRuleNode* aHighestNode,
+                          RuleDetail aRuleDetail,
+                          const mozilla::RuleNodeCacheConditions aConditions);
+
+  const void*
+    ComputeMarginData(void* aStartStruct,
+                      const nsRuleData* aRuleData,
+                      nsStyleContext* aContext, nsRuleNode* aHighestNode,
+                      RuleDetail aRuleDetail,
+                      const mozilla::RuleNodeCacheConditions aConditions);
+
+  const void*
+    ComputeBorderData(void* aStartStruct,
+                      const nsRuleData* aRuleData,
+                      nsStyleContext* aContext, nsRuleNode* aHighestNode,
+                      RuleDetail aRuleDetail,
+                      const mozilla::RuleNodeCacheConditions aConditions);
+
+  const void*
+    ComputePaddingData(void* aStartStruct,
+                       const nsRuleData* aRuleData,
+                       nsStyleContext* aContext, nsRuleNode* aHighestNode,
+                       RuleDetail aRuleDetail,
+                       const mozilla::RuleNodeCacheConditions aConditions);
+
+  const void*
+    ComputeOutlineData(void* aStartStruct,
+                       const nsRuleData* aRuleData,
+                       nsStyleContext* aContext, nsRuleNode* aHighestNode,
+                       RuleDetail aRuleDetail,
+                       const mozilla::RuleNodeCacheConditions aConditions);
+
+  const void*
+    ComputeListData(void* aStartStruct,
+                    const nsRuleData* aRuleData,
+                    nsStyleContext* aContext, nsRuleNode* aHighestNode,
+                    RuleDetail aRuleDetail,
+                    const mozilla::RuleNodeCacheConditions aConditions);
+
+  const void*
+    ComputePositionData(void* aStartStruct,
+                        const nsRuleData* aRuleData,
+                        nsStyleContext* aContext, nsRuleNode* aHighestNode,
+                        RuleDetail aRuleDetail,
+                        const mozilla::RuleNodeCacheConditions aConditions);
+
+  const void*
+    ComputeTableData(void* aStartStruct,
+                     const nsRuleData* aRuleData,
+                     nsStyleContext* aContext, nsRuleNode* aHighestNode,
+                     RuleDetail aRuleDetail,
+                     const mozilla::RuleNodeCacheConditions aConditions);
+
+  const void*
+    ComputeTableBorderData(void* aStartStruct,
+                           const nsRuleData* aRuleData,
+                           nsStyleContext* aContext, nsRuleNode* aHighestNode,
+                           RuleDetail aRuleDetail,
+                           const mozilla::RuleNodeCacheConditions aConditions);
+
+  const void*
+    ComputeContentData(void* aStartStruct,
+                       const nsRuleData* aRuleData,
+                       nsStyleContext* aContext, nsRuleNode* aHighestNode,
+                       RuleDetail aRuleDetail,
+                       const mozilla::RuleNodeCacheConditions aConditions);
+
+  const void*
+    ComputeTextData(void* aStartStruct,
+                    const nsRuleData* aRuleData,
+                    nsStyleContext* aContext, nsRuleNode* aHighestNode,
+                    RuleDetail aRuleDetail,
+                    const mozilla::RuleNodeCacheConditions aConditions);
+
+  const void*
+    ComputeTextResetData(void* aStartStruct,
+                         const nsRuleData* aRuleData,
+                         nsStyleContext* aContext, nsRuleNode* aHighestNode,
+                         RuleDetail aRuleDetail,
+                         const mozilla::RuleNodeCacheConditions aConditions);
+
+  const void*
+    ComputeUserInterfaceData(void* aStartStruct,
+                             const nsRuleData* aRuleData,
+                             nsStyleContext* aContext,
+                             nsRuleNode* aHighestNode,
+                             RuleDetail aRuleDetail,
+                             const mozilla::RuleNodeCacheConditions aConditions);
+
+  const void*
+    ComputeUIResetData(void* aStartStruct,
+                       const nsRuleData* aRuleData,
+                       nsStyleContext* aContext, nsRuleNode* aHighestNode,
+                       RuleDetail aRuleDetail,
+                       const mozilla::RuleNodeCacheConditions aConditions);
+
+  const void*
+    ComputeXULData(void* aStartStruct,
+                   const nsRuleData* aRuleData,
+                   nsStyleContext* aContext, nsRuleNode* aHighestNode,
+                   RuleDetail aRuleDetail,
+                   const mozilla::RuleNodeCacheConditions aConditions);
+
+  const void*
+    ComputeColumnData(void* aStartStruct,
+                      const nsRuleData* aRuleData,
+                      nsStyleContext* aContext, nsRuleNode* aHighestNode,
+                      RuleDetail aRuleDetail,
+                      const mozilla::RuleNodeCacheConditions aConditions);
+
+  const void*
+    ComputeSVGData(void* aStartStruct,
+                   const nsRuleData* aRuleData,
+                   nsStyleContext* aContext, nsRuleNode* aHighestNode,
+                   RuleDetail aRuleDetail,
+                   const mozilla::RuleNodeCacheConditions aConditions);
+
+  const void*
+    ComputeSVGResetData(void* aStartStruct,
+                        const nsRuleData* aRuleData,
+                        nsStyleContext* aContext, nsRuleNode* aHighestNode,
+                        RuleDetail aRuleDetail,
+                        const mozilla::RuleNodeCacheConditions aConditions);
+
+  const void*
+    ComputeVariablesData(void* aStartStruct,
+                         const nsRuleData* aRuleData,
+                         nsStyleContext* aContext, nsRuleNode* aHighestNode,
+                         RuleDetail aRuleDetail,
+                         const mozilla::RuleNodeCacheConditions aConditions);
+
+  const void*
+    ComputeEffectsData(void* aStartStruct,
+                       const nsRuleData* aRuleData,
+                       nsStyleContext* aContext, nsRuleNode* aHighestNode,
+                       RuleDetail aRuleDetail,
+                       const mozilla::RuleNodeCacheConditions aConditions);
+
+  // helpers for |ComputeFontData| that need access to |mNoneBits|:
+  static void SetFontSize(nsPresContext* aPresContext,
+                          nsStyleContext* aContext,
+                          const nsRuleData* aRuleData,
+                          const nsStyleFont* aFont,
+                          const nsStyleFont* aParentFont,
+                          nscoord* aSize,
+                          const nsFont& aSystemFont,
+                          nscoord aParentSize,
+                          nscoord aScriptLevelAdjustedParentSize,
+                          bool aUsedStartStruct,
+                          bool aAtRoot,
+                          mozilla::RuleNodeCacheConditions& aConditions);
+
+  static void SetFont(nsPresContext* aPresContext,
+                      nsStyleContext* aContext,
+                      uint8_t aGenericFontID,
+                      const nsRuleData* aRuleData,
+                      const nsStyleFont* aParentFont,
+                      nsStyleFont* aFont,
+                      bool aStartStruct,
+                      mozilla::RuleNodeCacheConditions& aConditions);
+
+  static void SetGenericFont(nsPresContext* aPresContext,
+                             nsStyleContext* aContext,
+                             uint8_t aGenericFontID,
+                             nsStyleFont* aFont);
+
+  inline RuleDetail CheckSpecifiedProperties(const nsStyleStructID aSID,
+                                             const nsRuleData* aRuleData);
+
+private:
+  nsRuleNode(nsPresContext* aPresContext, nsRuleNode* aParent,
+             nsIStyleRule* aRule, mozilla::SheetType aLevel, bool aIsImportant);
+  ~nsRuleNode();
+
+public:
+  // This is infallible; it will never return nullptr.
+  static already_AddRefed<nsRuleNode> CreateRootNode(nsPresContext* aPresContext);
+
+  static void EnsureBlockDisplay(mozilla::StyleDisplay& display,
+                                 bool aConvertListItem = false);
+  static void EnsureInlineDisplay(mozilla::StyleDisplay& display);
+
+  // Transition never returns null; on out of memory it'll just return |this|.
+  nsRuleNode* Transition(nsIStyleRule* aRule, mozilla::SheetType aLevel,
+                         bool aIsImportantRule);
+  nsRuleNode* GetParent() const { return mParent; }
+  bool IsRoot() const { return mParent == nullptr; }
+
+  // Return the root of the rule tree that this rule node is in.
+  nsRuleNode* RuleTree();
+  const nsRuleNode* RuleTree() const {
+    return const_cast<nsRuleNode*>(this)->RuleTree();
+  }
+
+  mozilla::SheetType GetLevel() const {
+    NS_ASSERTION(!IsRoot(), "can't call on root");
+    return mozilla::SheetType(
+        (mDependentBits & NS_RULE_NODE_LEVEL_MASK) >>
+          NS_RULE_NODE_LEVEL_SHIFT);
+  }
+  bool IsImportantRule() const {
+    NS_ASSERTION(!IsRoot(), "can't call on root");
+    return (mDependentBits & NS_RULE_NODE_IS_IMPORTANT) != 0;
+  }
+
+  /**
+   * Has this rule node at some time in its lifetime been the mRuleNode
+   * of some style context (as opposed to only being the ancestor of
+   * some style context's mRuleNode)?
+   */
+  void SetUsedDirectly();
+  bool IsUsedDirectly() const {
+    return (mDependentBits & NS_RULE_NODE_USED_DIRECTLY) != 0;
+  }
+
+  /**
+   * Is the mRule of this rule node an AnimValuesStyleRule?
+   */
+  void SetIsAnimationRule() {
+    MOZ_ASSERT(!HaveChildren() ||
+               (mDependentBits & NS_RULE_NODE_IS_ANIMATION_RULE),
+               "SetIsAnimationRule must only set the IS_ANIMATION_RULE bit "
+               "before the rule node has children");
+    mDependentBits |= NS_RULE_NODE_IS_ANIMATION_RULE;
+    mNoneBits |= NS_RULE_NODE_HAS_ANIMATION_DATA;
+  }
+  bool IsAnimationRule() const {
+    return (mDependentBits & NS_RULE_NODE_IS_ANIMATION_RULE) != 0;
+  }
+
+  /**
+   * Is the mRule of this rule node or any of its ancestors an
+   * AnimValuesStyleRule?
+   */
+  bool HasAnimationData() const {
+    return (mNoneBits & NS_RULE_NODE_HAS_ANIMATION_DATA) != 0;
+  }
+
+  // NOTE:  Does not |AddRef|.  Null only for the root.
+  nsIStyleRule* GetRule() const { return mRule; }
+  // NOTE: Does not |AddRef|.  Never null.
+  nsPresContext* PresContext() const { return mPresContext; }
+
+  const void* GetStyleData(nsStyleStructID aSID,
+                           nsStyleContext* aContext,
+                           bool aComputeData);
+
+  void GetDiscretelyAnimatedCSSValue(nsCSSPropertyID aProperty,
+                                     nsCSSValue* aValue);
+
+  // See comments in GetStyleData for an explanation of what the
+  // code below does.
+  #define STYLE_STRUCT_INHERITED(name_, checkdata_cb_)                        \
+  template<bool aComputeData>                                                 \
+  const nsStyle##name_*                                                       \
+  GetStyle##name_(nsStyleContext* aContext, uint64_t& aContextStyleBits)      \
+  {                                                                           \
+    NS_ASSERTION(IsUsedDirectly(),                                            \
+                 "if we ever call this on rule nodes that aren't used "       \
+                 "directly, we should adjust handling of mDependentBits "     \
+                 "in some way.");                                             \
+    MOZ_ASSERT(!ContextHasCachedData(aContext, eStyleStruct_##name_),         \
+               "style context should not have cached data for struct");       \
+                                                                              \
+    const nsStyle##name_ *data;                                               \
+                                                                              \
+    /* Never use cached data for animated style inside a pseudo-element; */   \
+    /* see comment on cacheability in AnimValuesStyleRule::MapRuleInfoInto */ \
+    if (!(HasAnimationData() && ParentHasPseudoElementData(aContext))) {      \
+      data = mStyleData.GetStyle##name_();                                    \
+      if (data != nullptr) {                                                  \
+        /* For inherited structs, mark the struct (which will be set on */    \
+        /* the context by our caller) as not being owned by the context. */   \
+        /* Normally this would be aContext->AddStyleBit(), but aContext is */ \
+        /* an incomplete type here, so we work around that with a param. */   \
+        aContextStyleBits |= NS_STYLE_INHERIT_BIT(name_);                     \
+        /* Our caller will cache the data on the style context. */            \
+        return data;                                                          \
+      }                                                                       \
+    }                                                                         \
+                                                                              \
+    if (!aComputeData)                                                        \
+      return nullptr;                                                         \
+                                                                              \
+    data = static_cast<const nsStyle##name_ *>                                \
+             (WalkRuleTree(eStyleStruct_##name_, aContext));                  \
+                                                                              \
+    MOZ_ASSERT(data, "should have aborted on out-of-memory");                 \
+    return data;                                                              \
+  }
+
+  #define STYLE_STRUCT_RESET(name_, checkdata_cb_)                            \
+  template<bool aComputeData>                                                 \
+  const nsStyle##name_*                                                       \
+  GetStyle##name_(nsStyleContext* aContext)                                   \
+  {                                                                           \
+    NS_ASSERTION(IsUsedDirectly(),                                            \
+                 "if we ever call this on rule nodes that aren't used "       \
+                 "directly, we should adjust handling of mDependentBits "     \
+                 "in some way.");                                             \
+    MOZ_ASSERT(!ContextHasCachedData(aContext, eStyleStruct_##name_),         \
+               "style context should not have cached data for struct");       \
+                                                                              \
+    const nsStyle##name_ *data;                                               \
+                                                                              \
+    /* Never use cached data for animated style inside a pseudo-element; */   \
+    /* see comment on cacheability in AnimValuesStyleRule::MapRuleInfoInto */ \
+    if (!(HasAnimationData() && ParentHasPseudoElementData(aContext))) {      \
+      data = mStyleData.GetStyle##name_(aContext, aComputeData);              \
+      if (MOZ_LIKELY(data != nullptr)) {                                      \
+        if (HasAnimationData()) {                                             \
+          /* If we have animation data, the struct should be cached on the */ \
+          /* style context so that we can peek the struct. */                 \
+          /* See comment in AnimValuesStyleRule::MapRuleInfoInto. */          \
+          StoreStyleOnContext(aContext,                                       \
+                              eStyleStruct_##name_,                           \
+                              const_cast<nsStyle##name_*>(data));             \
+        }                                                                     \
+        return data;                                                          \
+      }                                                                       \
+    }                                                                         \
+                                                                              \
+    if (!aComputeData)                                                        \
+      return nullptr;                                                         \
+                                                                              \
+    data = static_cast<const nsStyle##name_ *>                                \
+             (WalkRuleTree(eStyleStruct_##name_, aContext));                  \
+                                                                              \
+    MOZ_ASSERT(data, "should have aborted on out-of-memory");                 \
+    return data;                                                              \
+  }
+
+  #include "nsStyleStructList.h"
+
+  #undef STYLE_STRUCT_RESET
+  #undef STYLE_STRUCT_INHERITED
+
+  static bool
+    HasAuthorSpecifiedRules(nsStyleContext* aStyleContext,
+                            uint32_t ruleTypeMask,
+                            bool aAuthorColorsAllowed);
+
+  /**
+   * Fill in to aPropertiesOverridden all of the properties in aProperties
+   * that, for this rule node, have a declaration that is higher than the
+   * animation level in the CSS Cascade.
+   */
+  static void
+  ComputePropertiesOverridingAnimation(
+                              const nsTArray<nsCSSPropertyID>& aProperties,
+                              nsStyleContext* aStyleContext,
+                              nsCSSPropertyIDSet& aPropertiesOverridden);
+
+  // Expose this so media queries can use it
+  static nscoord CalcLengthWithInitialFont(nsPresContext* aPresContext,
+                                           const nsCSSValue& aValue);
+  // Expose this so nsTransformFunctions can use it.
+  static nscoord CalcLength(const nsCSSValue& aValue,
+                            nsStyleContext* aStyleContext,
+                            nsPresContext* aPresContext,
+                            mozilla::RuleNodeCacheConditions& aConditions);
+
+  struct ComputedCalc {
+    nscoord mLength;
+    float mPercent;
+
+    ComputedCalc(nscoord aLength, float aPercent)
+      : mLength(aLength), mPercent(aPercent) {}
+  };
+  static ComputedCalc
+  SpecifiedCalcToComputedCalc(const nsCSSValue& aValue,
+                              nsStyleContext* aStyleContext,
+                              nsPresContext* aPresContext,
+                              mozilla::RuleNodeCacheConditions& aConditions);
+
+  // Compute the value of an nsStyleCoord that IsCalcUnit().
+  // (Values that don't require aPercentageBasis should be handled
+  // inside nsRuleNode rather than through this API.)
+  // @note the caller is expected to handle percentage of an indefinite size
+  // and NOT call this method with aPercentageBasis == NS_UNCONSTRAINEDSIZE.
+  // @note the return value may be negative, e.g. for "calc(a - b%)"
+  static nscoord ComputeComputedCalc(const nsStyleCoord& aCoord,
+                                     nscoord aPercentageBasis);
+
+  // Compute the value of an nsStyleCoord that is either a coord, a
+  // percent, or a calc expression.
+  // @note the caller is expected to handle percentage of an indefinite size
+  // and NOT call this method with aPercentageBasis == NS_UNCONSTRAINEDSIZE.
+  // @note the return value may be negative, e.g. for "calc(a - b%)"
+  static nscoord ComputeCoordPercentCalc(const nsStyleCoord& aCoord,
+                                         nscoord aPercentageBasis);
+
+  // Return whether the rule tree for which this node is the root has
+  // cached data such that we need to do dynamic change handling for
+  // changes that change the results of media queries or require
+  // rebuilding all style data.
+  bool TreeHasCachedData() const {
+    NS_ASSERTION(IsRoot(), "should only be called on root of rule tree");
+    return HaveChildren() || mStyleData.mInheritedData || mStyleData.mResetData;
+  }
+
+  // Note that this will return false if we have cached conditional
+  // style structs.
+  bool NodeHasCachedUnconditionalData(const nsStyleStructID aSID) {
+    return !!mStyleData.GetStyleData(aSID);
+  }
+
+  static void ComputeFontFeatures(const nsCSSValuePairList *aFeaturesList,
+                                  nsTArray<gfxFontFeature>& aFeatureSettings);
+
+  static nscoord CalcFontPointSize(int32_t aHTMLSize, int32_t aBasePointSize,
+                                   nsPresContext* aPresContext,
+                                   nsFontSizeType aFontSizeType = eFontSize_HTML);
+
+  static nscoord FindNextSmallerFontSize(nscoord aFontSize, int32_t aBasePointSize,
+                                         nsPresContext* aPresContext,
+                                         nsFontSizeType aFontSizeType = eFontSize_HTML);
+
+  static nscoord FindNextLargerFontSize(nscoord aFontSize, int32_t aBasePointSize,
+                                        nsPresContext* aPresContext,
+                                        nsFontSizeType aFontSizeType = eFontSize_HTML);
+
+  /**
+   * @param aValue The color value, returned from nsCSSParser::ParseColorString
+   * @param aPresContext Presentation context whose preferences are used
+   *                     for certain enumerated colors
+   * @param aStyleContext Style context whose color is used for 'currentColor'
+   *
+   * @note aPresContext and aStyleContext may be null, but in that case, fully
+   *       opaque black will be returned for the values that rely on these
+   *       objects to compute the color. (For example, -moz-hyperlinktext.)
+   *
+   * @return false if we fail to extract a color; this will not happen if both
+   *         aPresContext and aStyleContext are non-null
+   */
+  static bool ComputeColor(const nsCSSValue& aValue,
+                           nsPresContext* aPresContext,
+                           nsStyleContext* aStyleContext,
+                           nscolor& aResult);
+
+  static bool ParentHasPseudoElementData(nsStyleContext* aContext);
+
+  static void ComputeTimingFunction(const nsCSSValue& aValue,
+                                    nsTimingFunction& aResult);
+
+  // Fill unspecified layers by cycling through their values
+  // till they all are of length aMaxItemCount
+  static void FillAllBackgroundLists(nsStyleImageLayers& aLayers,
+                                     uint32_t aMaxItemCount);
+
+  static void FillAllMaskLists(nsStyleImageLayers& aLayers,
+                               uint32_t aMaxItemCount);
+
+private:
+#ifdef DEBUG
+  // non-inline helper function to allow assertions without incomplete
+  // type errors
+  bool ContextHasCachedData(nsStyleContext* aContext, nsStyleStructID aSID);
+#endif
+
+  // Store style struct on the style context and tell the style context
+  // that it doesn't own the data
+  static void StoreStyleOnContext(nsStyleContext* aContext,
+                                  nsStyleStructID aSID,
+                                  void* aStruct);
+};
+
+#endif