The Tor Browser: layout/style/nsRuleNode.h@97036ab72558 (annotated)

layout/style/nsRuleNode.h@97036ab72558 (annotated)

layout/style/nsRuleNode.h

Tue, 06 Jan 2015 21:39:09 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Tue, 06 Jan 2015 21:39:09 +0100
branch: TOR_BUG_9701
changeset 8: 97036ab72558
permissions: -rw-r--r--

Conditionally force memory storage according to privacy.thirdparty.isolate;
This solves Tor bug #9701, complying with disk avoidance documented in
https://www.torproject.org/projects/torbrowser/design/#disk-avoidance.

 /* -*- 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 "nsPresContext.h"
 #include "nsStyleStruct.h"
 #include <stdint.h>
 class nsStyleContext;
 struct nsRuleData;
 class nsIStyleRule;
 struct nsCSSValueList;
 class nsCSSValue;
 struct nsCSSRect;
 class nsStyleCoord;
 struct nsCSSValuePairList;
 template <nsStyleStructID MinIndex, nsStyleStructID Count>
 class FixedStyleStructArray
 {
 private:
   void* mArray[Count];
 public:
   void*& operator[](nsStyleStructID aIndex) {
     NS_ABORT_IF_FALSE(MinIndex <= aIndex && aIndex < (MinIndex + Count),
                       "out of range");
     return mArray[aIndex - MinIndex];
   }
   const void* operator[](nsStyleStructID aIndex) const {
     NS_ABORT_IF_FALSE(MinIndex <= aIndex && aIndex < (MinIndex + Count),
                       "out of range");
     return mArray[aIndex - MinIndex];
   }
 };
 struct nsInheritedStyleData
 {
   FixedStyleStructArray<nsStyleStructID_Inherited_Start,
                         nsStyleStructID_Inherited_Count> mStyleStructs;
   void* operator new(size_t sz, nsPresContext* aContext) CPP_THROW_NEW {
     return aContext->AllocateFromShell(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->FreeToShell(sizeof(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
 {
   FixedStyleStructArray<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) CPP_THROW_NEW {
     return aContext->AllocateFromShell(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->FreeToShell(sizeof(nsResetStyleData), this);
   }
 };
 struct nsCachedStyleData
 {
   nsInheritedStyleData* mInheritedData;
   nsResetStyleData* mResetData;
   static bool IsReset(const nsStyleStructID aSID) {
     NS_ABORT_IF_FALSE(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 1 << aSID;
   }
   void* NS_FASTCALL GetStyleData(const nsStyleStructID aSID) {
     if (IsReset(aSID)) {
       if (mResetData) {
         return mResetData->mStyleStructs[aSID];
       }
     } 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) nsResetStyleData;
       }
       mResetData->mStyleStructs[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_ () {                    \
       return mResetData ? static_cast<nsStyle##name_*>(                  \
         mResetData->mStyleStructs[eStyleStruct_##name_]) : 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.  It is garbage-collected
  * (using mark-and-sweep garbage collection) during the lifetime of the
  * document (when dynamic changes cause the destruction of enough style
  * contexts).  Rule nodes are marked if they are pointed to by a style
  * context or one of their descendants is.
  *
  * 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
 };
 class 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.
   nsRuleNode* const 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.
   nsIStyleRule* const mRule; // [STRONG] 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;
     uint8_t mLevel;
     bool mIsImportantRule;
     Key(nsIStyleRule* aRule, uint8_t 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(PLDHashTable *aTable, const void *aKey);
   static bool
   ChildrenHashMatchEntry(PLDHashTable *aTable,
                          const PLDHashEntryHdr *aHdr,
                          const void *aKey);
   static const PLDHashTableOps ChildrenHashOps;
   static PLDHashOperator
   EnqueueRuleNodeChildren(PLDHashTable *table, PLDHashEntryHdr *hdr,
                           uint32_t number, void *arg);
   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();
   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.  This just counts the style contexts that reference this
   // rulenode.  And children the rulenode has had.  When this goes to 0 or
   // stops being 0, we notify the style set.
   // Note, in particular, that when a child is removed mRefCnt is NOT
   // decremented.  This is on purpose; the notifications to the style set are
   // only used to determine when it's worth running GC on the ruletree, and
   // this setup makes it so we only count unused ruletree leaves for purposes
   // of deciding when to GC.  We could more accurately count unused rulenodes
   // by releasing/addrefing our parent when our refcount transitions to or from
   // 0, but it doesn't seem worth it to do that.
   uint32_t mRefCnt;
 public:
   // Overloaded new operator. Initializes the memory to 0 and relies on an arena
   // (which comes from the presShell) to perform the allocation.
   void* operator new(size_t sz, nsPresContext* aContext) CPP_THROW_NEW;
   void Destroy() { DestroyInternal(nullptr); }
   // 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 DestroyInternal(nsRuleNode ***aDestroyQueueTail);
   void PropagateDependentBit(nsStyleStructID aSID, nsRuleNode* aHighestNode,
                              void* aStruct);
   void PropagateNoneBit(uint32_t aBit, nsRuleNode* aHighestNode);
   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 bool aCanStoreInRuleTree);
   const void*
     ComputeVisibilityData(void* aStartStruct,
                           const nsRuleData* aRuleData,
                           nsStyleContext* aContext, nsRuleNode* aHighestNode,
                           RuleDetail aRuleDetail,
                           const bool aCanStoreInRuleTree);
   const void*
     ComputeFontData(void* aStartStruct,
                     const nsRuleData* aRuleData,
                     nsStyleContext* aContext, nsRuleNode* aHighestNode,
                     RuleDetail aRuleDetail,
                     const bool aCanStoreInRuleTree);
   const void*
     ComputeColorData(void* aStartStruct,
                      const nsRuleData* aRuleData,
                      nsStyleContext* aContext, nsRuleNode* aHighestNode,
                      RuleDetail aRuleDetail,
                      const bool aCanStoreInRuleTree);
   const void*
     ComputeBackgroundData(void* aStartStruct,
                           const nsRuleData* aRuleData,
                           nsStyleContext* aContext, nsRuleNode* aHighestNode,
                           RuleDetail aRuleDetail,
                           const bool aCanStoreInRuleTree);
   const void*
     ComputeMarginData(void* aStartStruct,
                       const nsRuleData* aRuleData,
                       nsStyleContext* aContext, nsRuleNode* aHighestNode,
                       RuleDetail aRuleDetail,
                       const bool aCanStoreInRuleTree);
   const void*
     ComputeBorderData(void* aStartStruct,
                       const nsRuleData* aRuleData,
                       nsStyleContext* aContext, nsRuleNode* aHighestNode,
                       RuleDetail aRuleDetail,
                       const bool aCanStoreInRuleTree);
   const void*
     ComputePaddingData(void* aStartStruct,
                        const nsRuleData* aRuleData,
                        nsStyleContext* aContext, nsRuleNode* aHighestNode,
                        RuleDetail aRuleDetail,
                        const bool aCanStoreInRuleTree);
   const void*
     ComputeOutlineData(void* aStartStruct,
                        const nsRuleData* aRuleData,
                        nsStyleContext* aContext, nsRuleNode* aHighestNode,
                        RuleDetail aRuleDetail,
                        const bool aCanStoreInRuleTree);
   const void*
     ComputeListData(void* aStartStruct,
                     const nsRuleData* aRuleData,
                     nsStyleContext* aContext, nsRuleNode* aHighestNode,
                     RuleDetail aRuleDetail,
                     const bool aCanStoreInRuleTree);
   const void*
     ComputePositionData(void* aStartStruct,
                         const nsRuleData* aRuleData,
                         nsStyleContext* aContext, nsRuleNode* aHighestNode,
                         RuleDetail aRuleDetail,
                         const bool aCanStoreInRuleTree);
   const void*
     ComputeTableData(void* aStartStruct,
                      const nsRuleData* aRuleData,
                      nsStyleContext* aContext, nsRuleNode* aHighestNode,
                      RuleDetail aRuleDetail,
                      const bool aCanStoreInRuleTree);
   const void*
     ComputeTableBorderData(void* aStartStruct,
                            const nsRuleData* aRuleData,
                            nsStyleContext* aContext, nsRuleNode* aHighestNode,
                            RuleDetail aRuleDetail,
                            const bool aCanStoreInRuleTree);
   const void*
     ComputeContentData(void* aStartStruct,
                        const nsRuleData* aRuleData,
                        nsStyleContext* aContext, nsRuleNode* aHighestNode,
                        RuleDetail aRuleDetail,
                        const bool aCanStoreInRuleTree);
   const void*
     ComputeQuotesData(void* aStartStruct,
                       const nsRuleData* aRuleData,
                       nsStyleContext* aContext, nsRuleNode* aHighestNode,
                       RuleDetail aRuleDetail,
                       const bool aCanStoreInRuleTree);
   const void*
     ComputeTextData(void* aStartStruct,
                     const nsRuleData* aRuleData,
                     nsStyleContext* aContext, nsRuleNode* aHighestNode,
                     RuleDetail aRuleDetail,
                     const bool aCanStoreInRuleTree);
   const void*
     ComputeTextResetData(void* aStartStruct,
                          const nsRuleData* aRuleData,
                          nsStyleContext* aContext, nsRuleNode* aHighestNode,
                          RuleDetail aRuleDetail,
                          const bool aCanStoreInRuleTree);
   const void*
     ComputeUserInterfaceData(void* aStartStruct,
                              const nsRuleData* aRuleData,
                              nsStyleContext* aContext,
                              nsRuleNode* aHighestNode,
                              RuleDetail aRuleDetail,
                              const bool aCanStoreInRuleTree);
   const void*
     ComputeUIResetData(void* aStartStruct,
                        const nsRuleData* aRuleData,
                        nsStyleContext* aContext, nsRuleNode* aHighestNode,
                        RuleDetail aRuleDetail,
                        const bool aCanStoreInRuleTree);
   const void*
     ComputeXULData(void* aStartStruct,
                    const nsRuleData* aRuleData,
                    nsStyleContext* aContext, nsRuleNode* aHighestNode,
                    RuleDetail aRuleDetail,
                    const bool aCanStoreInRuleTree);
   const void*
     ComputeColumnData(void* aStartStruct,
                       const nsRuleData* aRuleData,
                       nsStyleContext* aContext, nsRuleNode* aHighestNode,
                       RuleDetail aRuleDetail,
                       const bool aCanStoreInRuleTree);
   const void*
     ComputeSVGData(void* aStartStruct,
                    const nsRuleData* aRuleData,
                    nsStyleContext* aContext, nsRuleNode* aHighestNode,
                    RuleDetail aRuleDetail,
                    const bool aCanStoreInRuleTree);
   const void*
     ComputeSVGResetData(void* aStartStruct,
                         const nsRuleData* aRuleData,
                         nsStyleContext* aContext, nsRuleNode* aHighestNode,
                         RuleDetail aRuleDetail,
                         const bool aCanStoreInRuleTree);
   const void*
     ComputeVariablesData(void* aStartStruct,
                          const nsRuleData* aRuleData,
                          nsStyleContext* aContext, nsRuleNode* aHighestNode,
                          RuleDetail aRuleDetail,
                          const bool aCanStoreInRuleTree);
   // helpers for |ComputeFontData| that need access to |mNoneBits|:
   static void SetFontSize(nsPresContext* aPresContext,
                           const nsRuleData* aRuleData,
                           const nsStyleFont* aFont,
                           const nsStyleFont* aParentFont,
                           nscoord* aSize,
                           const nsFont& aSystemFont,
                           nscoord aParentSize,
                           nscoord aScriptLevelAdjustedParentSize,
                           bool aUsedStartStruct,
                           bool aAtRoot,
                           bool& aCanStoreInRuleTree);
   static void SetFont(nsPresContext* aPresContext,
                       nsStyleContext* aContext,
                       uint8_t aGenericFontID,
                       const nsRuleData* aRuleData,
                       const nsStyleFont* aParentFont,
                       nsStyleFont* aFont,
                       bool aStartStruct,
                       bool& aCanStoreInRuleTree);
   static void SetGenericFont(nsPresContext* aPresContext,
                              nsStyleContext* aContext,
                              uint8_t aGenericFontID,
                              nsStyleFont* aFont);
   void AdjustLogicalBoxProp(nsStyleContext* aContext,
                             const nsCSSValue& aLTRSource,
                             const nsCSSValue& aRTLSource,
                             const nsCSSValue& aLTRLogicalValue,
                             const nsCSSValue& aRTLLogicalValue,
                             mozilla::css::Side aSide,
                             nsCSSRect& aValueRect,
                             bool& aCanStoreInRuleTree);
   inline RuleDetail CheckSpecifiedProperties(const nsStyleStructID aSID,
                                              const nsRuleData* aRuleData);
   already_AddRefed<nsCSSShadowArray>
               GetShadowData(const nsCSSValueList* aList,
                             nsStyleContext* aContext,
                             bool aIsBoxShadow,
                             bool& aCanStoreInRuleTree);
   bool SetStyleFilterToCSSValue(nsStyleFilter* aStyleFilter,
                                 const nsCSSValue& aValue,
                                 nsStyleContext* aStyleContext,
                                 nsPresContext* aPresContext,
                                 bool& aCanStoreInRuleTree);
 private:
   nsRuleNode(nsPresContext* aPresContext, nsRuleNode* aParent,
              nsIStyleRule* aRule, uint8_t aLevel, bool aIsImportant);
   ~nsRuleNode();
 public:
   static nsRuleNode* CreateRootNode(nsPresContext* aPresContext);
   static void EnsureBlockDisplay(uint8_t& display,
                                  bool aConvertListItem = false);
   // Transition never returns null; on out of memory it'll just return |this|.
   nsRuleNode* Transition(nsIStyleRule* aRule, uint8_t aLevel,
                          bool aIsImportantRule);
   nsRuleNode* GetParent() const { return mParent; }
   bool IsRoot() const { return mParent == nullptr; }
   // These uint8_ts are really nsStyleSet::sheetType values.
   uint8_t GetLevel() const {
     NS_ASSERTION(!IsRoot(), "can't call on root");
     return (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;
   }
   // 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);
   #define STYLE_STRUCT(name_, checkdata_cb_)                                  \
     const nsStyle##name_* GetStyle##name_(nsStyleContext* aContext,           \
                                           bool aComputeData);
   #include "nsStyleStructList.h"
   #undef STYLE_STRUCT
   /*
    * Garbage collection.  Mark walks up the tree, marking any unmarked
    * ancestors until it reaches a marked one.  Sweep recursively sweeps
    * the children, destroys any that are unmarked, and clears marks,
    * returning true if the node on which it was called was destroyed.
    */
   void Mark();
   bool Sweep();
   static bool
     HasAuthorSpecifiedRules(nsStyleContext* aStyleContext,
                             uint32_t ruleTypeMask,
                             bool aAuthorColorsAllowed);
   // 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,
                             bool& aCanStoreInRuleTree);
   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,
                               bool& aCanStoreInRuleTree);
   // Compute the value of an nsStyleCoord that IsCalcUnit().
   // (Values that don't require aPercentageBasis should be handled
   // inside nsRuleNode rather than through this API.)
   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.
   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;
   }
   bool NodeHasCachedData(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);
 };
 #endif

The Tor Browser / annotate

layout/style/nsRuleNode.h@97036ab72558 (annotated)

layout/style/nsRuleNode.h