michael@0: /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
michael@0: /* This Source Code Form is subject to the terms of the Mozilla Public
michael@0:  * License, v. 2.0. If a copy of the MPL was not distributed with this
michael@0:  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
michael@0: 
michael@0: /*
michael@0:  * data structures passed to nsIStyleRuleProcessor methods (to pull loop
michael@0:  * invariant computations out of the loop)
michael@0:  */
michael@0: 
michael@0: #ifndef nsRuleProcessorData_h_
michael@0: #define nsRuleProcessorData_h_
michael@0: 
michael@0: #include "nsPresContext.h" // for nsCompatibility
michael@0: #include "nsString.h"
michael@0: #include "nsChangeHint.h"
michael@0: #include "nsCSSPseudoElements.h"
michael@0: #include "nsRuleWalker.h"
michael@0: #include "nsNthIndexCache.h"
michael@0: #include "nsILoadContext.h"
michael@0: #include "nsIDocument.h"
michael@0: #include "mozilla/AutoRestore.h"
michael@0: #include "mozilla/BloomFilter.h"
michael@0: #include "mozilla/EventStates.h"
michael@0: #include "mozilla/GuardObjects.h"
michael@0: 
michael@0: class nsAttrValue;
michael@0: class nsIAtom;
michael@0: class nsIContent;
michael@0: class nsICSSPseudoComparator;
michael@0: class nsIStyleSheet;
michael@0: struct TreeMatchContext;
michael@0: 
michael@0: /**
michael@0:  * An AncestorFilter is used to keep track of ancestors so that we can
michael@0:  * quickly tell that a particular selector is not relevant to a given
michael@0:  * element.
michael@0:  */
michael@0: class MOZ_STACK_CLASS AncestorFilter {
michael@0:   friend struct TreeMatchContext;
michael@0:  public:
michael@0:   /* Maintenance of our ancestor state */
michael@0:   void PushAncestor(mozilla::dom::Element *aElement);
michael@0:   void PopAncestor();
michael@0: 
michael@0:   /* Check whether we might have an ancestor matching one of the given
michael@0:      atom hashes.  |hashes| must have length hashListLength */
michael@0:   template<size_t hashListLength>
michael@0:     bool MightHaveMatchingAncestor(const uint32_t* aHashes) const
michael@0:   {
michael@0:     MOZ_ASSERT(mFilter);
michael@0:     for (size_t i = 0; i < hashListLength && aHashes[i]; ++i) {
michael@0:       if (!mFilter->mightContain(aHashes[i])) {
michael@0:         return false;
michael@0:       }
michael@0:     }
michael@0: 
michael@0:     return true;
michael@0:   }
michael@0: 
michael@0:   bool HasFilter() const { return mFilter; }
michael@0: 
michael@0: #ifdef DEBUG
michael@0:   void AssertHasAllAncestors(mozilla::dom::Element *aElement) const;
michael@0: #endif
michael@0:   
michael@0:  private:
michael@0:   // Using 2^12 slots makes the Bloom filter a nice round page in
michael@0:   // size, so let's do that.  We get a false positive rate of 1% or
michael@0:   // less even with several hundred things in the filter.  Note that
michael@0:   // we allocate the filter lazily, because not all tree match
michael@0:   // contexts can use one effectively.
michael@0:   typedef mozilla::BloomFilter<12, nsIAtom> Filter;
michael@0:   nsAutoPtr<Filter> mFilter;
michael@0: 
michael@0:   // Stack of indices to pop to.  These are indices into mHashes.
michael@0:   nsTArray<uint32_t> mPopTargets;
michael@0: 
michael@0:   // List of hashes; this is what we pop using mPopTargets.  We store
michael@0:   // hashes of our ancestor element tag names, ids, and classes in
michael@0:   // here.
michael@0:   nsTArray<uint32_t> mHashes;
michael@0: 
michael@0:   // A debug-only stack of Elements for use in assertions
michael@0: #ifdef DEBUG
michael@0:   nsTArray<mozilla::dom::Element*> mElements;
michael@0: #endif
michael@0: };
michael@0: 
michael@0: /**
michael@0:  * A |TreeMatchContext| has data about a matching operation.  The
michael@0:  * data are not node-specific but are invariants of the DOM tree the
michael@0:  * nodes being matched against are in.
michael@0:  *
michael@0:  * Most of the members are in parameters to selector matching.  The
michael@0:  * one out parameter is mHaveRelevantLink.  Consumers that use a
michael@0:  * TreeMatchContext for more than one matching operation and care
michael@0:  * about :visited and mHaveRelevantLink need to
michael@0:  * ResetForVisitedMatching() and ResetForUnvisitedMatching() as
michael@0:  * needed.
michael@0:  */
michael@0: struct MOZ_STACK_CLASS TreeMatchContext {
michael@0:   // Reset this context for matching for the style-if-:visited.
michael@0:   void ResetForVisitedMatching() {
michael@0:     NS_PRECONDITION(mForStyling, "Why is this being called?");
michael@0:     mHaveRelevantLink = false;
michael@0:     mVisitedHandling = nsRuleWalker::eRelevantLinkVisited;
michael@0:   }
michael@0:   
michael@0:   void ResetForUnvisitedMatching() {
michael@0:     NS_PRECONDITION(mForStyling, "Why is this being called?");
michael@0:     mHaveRelevantLink = false;
michael@0:     mVisitedHandling = nsRuleWalker::eRelevantLinkUnvisited;
michael@0:   }
michael@0: 
michael@0:   void SetHaveRelevantLink() { mHaveRelevantLink = true; }
michael@0:   bool HaveRelevantLink() const { return mHaveRelevantLink; }
michael@0: 
michael@0:   nsRuleWalker::VisitedHandlingType VisitedHandling() const
michael@0:   {
michael@0:     return mVisitedHandling;
michael@0:   }
michael@0: 
michael@0:   void AddScopeElement(mozilla::dom::Element* aElement) {
michael@0:     NS_PRECONDITION(mHaveSpecifiedScope,
michael@0:                     "Should be set before calling AddScopeElement()");
michael@0:     mScopes.AppendElement(aElement);
michael@0:   }
michael@0:   bool IsScopeElement(mozilla::dom::Element* aElement) const {
michael@0:     return mScopes.Contains(aElement);
michael@0:   }
michael@0:   void SetHasSpecifiedScope() {
michael@0:     mHaveSpecifiedScope = true;
michael@0:   }
michael@0:   bool HasSpecifiedScope() const {
michael@0:     return mHaveSpecifiedScope;
michael@0:   }
michael@0: 
michael@0:   /**
michael@0:    * Initialize the ancestor filter and list of style scopes.  If aElement is
michael@0:    * not null, it and all its ancestors will be passed to
michael@0:    * mAncestorFilter.PushAncestor and PushStyleScope, starting from the root and
michael@0:    * going down the tree.  Must only be called for elements in a document.
michael@0:    */
michael@0:   void InitAncestors(mozilla::dom::Element *aElement);
michael@0: 
michael@0:   /**
michael@0:    * Like InitAncestors, but only initializes the style scope list, not the
michael@0:    * ancestor filter.  May be called for elements outside a document.
michael@0:    */
michael@0:   void InitStyleScopes(mozilla::dom::Element* aElement);
michael@0: 
michael@0:   void PushStyleScope(mozilla::dom::Element* aElement)
michael@0:   {
michael@0:     NS_PRECONDITION(aElement, "aElement must not be null");
michael@0:     if (aElement->IsScopedStyleRoot()) {
michael@0:       mStyleScopes.AppendElement(aElement);
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   void PopStyleScope(mozilla::dom::Element* aElement)
michael@0:   {
michael@0:     NS_PRECONDITION(aElement, "aElement must not be null");
michael@0:     if (mStyleScopes.SafeLastElement(nullptr) == aElement) {
michael@0:       mStyleScopes.TruncateLength(mStyleScopes.Length() - 1);
michael@0:     }
michael@0:   }
michael@0:  
michael@0:   bool PopStyleScopeForSelectorMatching(mozilla::dom::Element* aElement)
michael@0:   {
michael@0:     NS_ASSERTION(mForScopedStyle, "only call PopStyleScopeForSelectorMatching "
michael@0:                                   "when mForScopedStyle is true");
michael@0: 
michael@0:     if (!mCurrentStyleScope) {
michael@0:       return false;
michael@0:     }
michael@0:     if (mCurrentStyleScope == aElement) {
michael@0:       mCurrentStyleScope = nullptr;
michael@0:     }
michael@0:     return true;
michael@0:   }
michael@0: 
michael@0: #ifdef DEBUG
michael@0:   void AssertHasAllStyleScopes(mozilla::dom::Element* aElement)
michael@0:   {
michael@0:     nsINode* cur = aElement->GetParentNode();
michael@0:     while (cur) {
michael@0:       if (cur->IsScopedStyleRoot()) {
michael@0:         MOZ_ASSERT(mStyleScopes.Contains(cur));
michael@0:       }
michael@0:       cur = cur->GetParentNode();
michael@0:     }
michael@0:   }
michael@0: #endif
michael@0: 
michael@0:   bool SetStyleScopeForSelectorMatching(mozilla::dom::Element* aSubject,
michael@0:                                         mozilla::dom::Element* aScope)
michael@0:   {
michael@0: #ifdef DEBUG
michael@0:     AssertHasAllStyleScopes(aSubject);
michael@0: #endif
michael@0: 
michael@0:     mForScopedStyle = !!aScope;
michael@0:     if (!aScope) {
michael@0:       // This is not for a scoped style sheet; return true, as we want
michael@0:       // selector matching to proceed.
michael@0:       mCurrentStyleScope = nullptr;
michael@0:       return true;
michael@0:     }
michael@0:     if (aScope == aSubject) {
michael@0:       // Although the subject is the same element as the scope, as soon
michael@0:       // as we continue with selector matching up the tree we don't want
michael@0:       // to match any more elements.  So we return true to indicate that
michael@0:       // we want to do the initial selector matching, but set
michael@0:       // mCurrentStyleScope to null so that no ancestor elements will match.
michael@0:       mCurrentStyleScope = nullptr;
michael@0:       return true;
michael@0:     }
michael@0:     if (mStyleScopes.Contains(aScope)) {
michael@0:       // mStyleScopes contains all of the scope elements that are ancestors of
michael@0:       // aSubject, so if aScope is in mStyleScopes, then we do want selector
michael@0:       // matching to proceed.
michael@0:       mCurrentStyleScope = aScope;
michael@0:       return true;
michael@0:     }
michael@0:     // Otherwise, we're not in the scope, and we don't want to proceed
michael@0:     // with selector matching.
michael@0:     mCurrentStyleScope = nullptr;
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   bool IsWithinStyleScopeForSelectorMatching() const
michael@0:   {
michael@0:     NS_ASSERTION(mForScopedStyle, "only call IsWithinScopeForSelectorMatching "
michael@0:                                   "when mForScopedStyle is true");
michael@0:     return mCurrentStyleScope;
michael@0:   }
michael@0: 
michael@0:   /* Helper class for maintaining the ancestor state */
michael@0:   class MOZ_STACK_CLASS AutoAncestorPusher {
michael@0:   public:
michael@0:     AutoAncestorPusher(TreeMatchContext& aTreeMatchContext
michael@0:                        MOZ_GUARD_OBJECT_NOTIFIER_PARAM)
michael@0:       : mPushedAncestor(false)
michael@0:       , mPushedStyleScope(false)
michael@0:       , mTreeMatchContext(aTreeMatchContext)
michael@0:       , mElement(nullptr)
michael@0:     {
michael@0:       MOZ_GUARD_OBJECT_NOTIFIER_INIT;
michael@0:     }
michael@0: 
michael@0:     void PushAncestorAndStyleScope(mozilla::dom::Element* aElement) {
michael@0:       MOZ_ASSERT(!mElement);
michael@0:       if (aElement) {
michael@0:         mElement = aElement;
michael@0:         mPushedAncestor = true;
michael@0:         mPushedStyleScope = true;
michael@0:         mTreeMatchContext.mAncestorFilter.PushAncestor(aElement);
michael@0:         mTreeMatchContext.PushStyleScope(aElement);
michael@0:       }
michael@0:     }
michael@0: 
michael@0:     void PushAncestorAndStyleScope(nsIContent* aContent) {
michael@0:       if (aContent && aContent->IsElement()) {
michael@0:         PushAncestorAndStyleScope(aContent->AsElement());
michael@0:       }
michael@0:     }
michael@0: 
michael@0:     void PushStyleScope(mozilla::dom::Element* aElement) {
michael@0:       MOZ_ASSERT(!mElement);
michael@0:       if (aElement) {
michael@0:         mElement = aElement;
michael@0:         mPushedStyleScope = true;
michael@0:         mTreeMatchContext.PushStyleScope(aElement);
michael@0:       }
michael@0:     }
michael@0: 
michael@0:     void PushStyleScope(nsIContent* aContent) {
michael@0:       if (aContent && aContent->IsElement()) {
michael@0:         PushStyleScope(aContent->AsElement());
michael@0:       }
michael@0:     }
michael@0: 
michael@0:     ~AutoAncestorPusher() {
michael@0:       if (mPushedAncestor) {
michael@0:         mTreeMatchContext.mAncestorFilter.PopAncestor();
michael@0:       }
michael@0:       if (mPushedStyleScope) {
michael@0:         mTreeMatchContext.PopStyleScope(mElement);
michael@0:       }
michael@0:     }
michael@0: 
michael@0:   private:
michael@0:     bool mPushedAncestor;
michael@0:     bool mPushedStyleScope;
michael@0:     TreeMatchContext& mTreeMatchContext;
michael@0:     mozilla::dom::Element* mElement;
michael@0:     MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER
michael@0:   };
michael@0: 
michael@0:   /* Helper class for tracking whether we're skipping the ApplyStyleFixups
michael@0:    * code for flex items.
michael@0:    *
michael@0:    * The optional second parameter aSkipFlexItemStyleFixup allows this
michael@0:    * class to be instantiated but only conditionally activated (e.g.
michael@0:    * in cases where we may or may not want to be skipping flex-item
michael@0:    * style fixup for a particular chunk of code).
michael@0:    */
michael@0:   class MOZ_STACK_CLASS AutoFlexItemStyleFixupSkipper {
michael@0:   public:
michael@0:     AutoFlexItemStyleFixupSkipper(TreeMatchContext& aTreeMatchContext,
michael@0:                                   bool aSkipFlexItemStyleFixup = true
michael@0:                                   MOZ_GUARD_OBJECT_NOTIFIER_PARAM)
michael@0:       : mAutoRestorer(aTreeMatchContext.mSkippingFlexItemStyleFixup)
michael@0:     {
michael@0:       MOZ_GUARD_OBJECT_NOTIFIER_INIT;
michael@0:       if (aSkipFlexItemStyleFixup) {
michael@0:         aTreeMatchContext.mSkippingFlexItemStyleFixup = true;
michael@0:       }
michael@0:     }
michael@0: 
michael@0:   private:
michael@0:     mozilla::AutoRestore<bool> mAutoRestorer;
michael@0:     MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER
michael@0:   };
michael@0: 
michael@0:   // Is this matching operation for the creation of a style context?
michael@0:   // (If it is, we need to set slow selector bits on nodes indicating
michael@0:   // that certain restyling needs to happen.)
michael@0:   const bool mForStyling;
michael@0: 
michael@0:  private:
michael@0:   // When mVisitedHandling is eRelevantLinkUnvisited, this is set to true if a
michael@0:   // relevant link (see explanation in definition of VisitedHandling enum) was
michael@0:   // encountered during the matching process, which means that matching needs
michael@0:   // to be rerun with eRelevantLinkVisited.  Otherwise, its behavior is
michael@0:   // undefined (it might get set appropriately, or might not).
michael@0:   bool mHaveRelevantLink;
michael@0: 
michael@0:   // If true, then our contextual reference element set is specified,
michael@0:   // and is given by mScopes.
michael@0:   bool mHaveSpecifiedScope;
michael@0: 
michael@0:   // How matching should be performed.  See the documentation for
michael@0:   // nsRuleWalker::VisitedHandlingType.
michael@0:   nsRuleWalker::VisitedHandlingType mVisitedHandling;
michael@0: 
michael@0:   // For matching :scope
michael@0:   nsAutoTArray<mozilla::dom::Element*, 1> mScopes;
michael@0:  public:
michael@0:   // The document we're working with.
michael@0:   nsIDocument* const mDocument;
michael@0: 
michael@0:   // Root of scoped stylesheet (set and unset by the supplier of the
michael@0:   // scoped stylesheet).
michael@0:   nsIContent* mScopedRoot;
michael@0: 
michael@0:   // Whether our document is HTML (as opposed to XML of some sort,
michael@0:   // including XHTML).
michael@0:   // XXX XBL2 issue: Should we be caching this?  What should it be for XBL2?
michael@0:   const bool mIsHTMLDocument;
michael@0: 
michael@0:   // Possibly remove use of mCompatMode in SelectorMatches?
michael@0:   // XXX XBL2 issue: Should we be caching this?  What should it be for XBL2?
michael@0:   const nsCompatibility mCompatMode;
michael@0: 
michael@0:   // The nth-index cache we should use
michael@0:   nsNthIndexCache mNthIndexCache;
michael@0: 
michael@0:   // An ancestor filter
michael@0:   AncestorFilter mAncestorFilter;
michael@0: 
michael@0:   // Whether this document is using PB mode
michael@0:   bool mUsingPrivateBrowsing;
michael@0: 
michael@0:   // Whether we're currently skipping the flex item chunk of ApplyStyleFixups
michael@0:   // when resolving style (e.g. for children of elements that have a mandatory
michael@0:   // frame-type and can't be flex containers despite having "display:flex").
michael@0:   bool mSkippingFlexItemStyleFixup;
michael@0: 
michael@0:   // Whether this TreeMatchContext is being used with an nsCSSRuleProcessor
michael@0:   // for an HTML5 scoped style sheet.
michael@0:   bool mForScopedStyle;
michael@0: 
michael@0:   enum MatchVisited {
michael@0:     eNeverMatchVisited,
michael@0:     eMatchVisitedDefault
michael@0:   };
michael@0: 
michael@0:   // List of ancestor elements that define a style scope (due to having a
michael@0:   // <style scoped> child).
michael@0:   nsAutoTArray<mozilla::dom::Element*, 1> mStyleScopes;
michael@0: 
michael@0:   // The current style scope element for selector matching.
michael@0:   mozilla::dom::Element* mCurrentStyleScope;
michael@0: 
michael@0:   // Constructor to use when creating a tree match context for styling
michael@0:   TreeMatchContext(bool aForStyling,
michael@0:                    nsRuleWalker::VisitedHandlingType aVisitedHandling,
michael@0:                    nsIDocument* aDocument,
michael@0:                    MatchVisited aMatchVisited = eMatchVisitedDefault)
michael@0:     : mForStyling(aForStyling)
michael@0:     , mHaveRelevantLink(false)
michael@0:     , mHaveSpecifiedScope(false)
michael@0:     , mVisitedHandling(aVisitedHandling)
michael@0:     , mDocument(aDocument)
michael@0:     , mScopedRoot(nullptr)
michael@0:     , mIsHTMLDocument(aDocument->IsHTML())
michael@0:     , mCompatMode(aDocument->GetCompatibilityMode())
michael@0:     , mUsingPrivateBrowsing(false)
michael@0:     , mSkippingFlexItemStyleFixup(false)
michael@0:     , mForScopedStyle(false)
michael@0:     , mCurrentStyleScope(nullptr)
michael@0:   {
michael@0:     if (aMatchVisited != eNeverMatchVisited) {
michael@0:       nsCOMPtr<nsISupports> container = mDocument->GetContainer();
michael@0:       if (container) {
michael@0:         nsCOMPtr<nsILoadContext> loadContext = do_QueryInterface(container);
michael@0:         NS_ASSERTION(loadContext, "Couldn't get loadContext from container; assuming no private browsing.");
michael@0:         if (loadContext) {
michael@0:           mUsingPrivateBrowsing = loadContext->UsePrivateBrowsing();
michael@0:         }
michael@0:       }
michael@0:     }
michael@0:   }
michael@0: };
michael@0: 
michael@0: struct MOZ_STACK_CLASS RuleProcessorData {
michael@0:   RuleProcessorData(nsPresContext* aPresContext,
michael@0:                     nsRuleWalker* aRuleWalker)
michael@0:     : mPresContext(aPresContext),
michael@0:       mRuleWalker(aRuleWalker),
michael@0:       mScope(nullptr)
michael@0:   {
michael@0:     NS_PRECONDITION(mPresContext, "Must have prescontext");
michael@0:   }
michael@0: 
michael@0:   nsPresContext* const mPresContext;
michael@0:   nsRuleWalker* const mRuleWalker; // Used to add rules to our results.
michael@0:   mozilla::dom::Element* mScope;
michael@0: };
michael@0: 
michael@0: struct MOZ_STACK_CLASS ElementDependentRuleProcessorData :
michael@0:                           public RuleProcessorData {
michael@0:   ElementDependentRuleProcessorData(nsPresContext* aPresContext,
michael@0:                                     mozilla::dom::Element* aElement,
michael@0:                                     nsRuleWalker* aRuleWalker,
michael@0:                                     TreeMatchContext& aTreeMatchContext)
michael@0:     : RuleProcessorData(aPresContext, aRuleWalker)
michael@0:     , mElement(aElement)
michael@0:     , mTreeMatchContext(aTreeMatchContext)
michael@0:   {
michael@0:     NS_ASSERTION(aElement, "null element leaked into SelectorMatches");
michael@0:     NS_ASSERTION(aElement->OwnerDoc(), "Document-less node here?");
michael@0:     NS_PRECONDITION(aTreeMatchContext.mForStyling == !!aRuleWalker,
michael@0:                     "Should be styling if and only if we have a rule walker");
michael@0:   }
michael@0:   
michael@0:   mozilla::dom::Element* const mElement; // weak ref, must not be null
michael@0:   TreeMatchContext& mTreeMatchContext;
michael@0: };
michael@0: 
michael@0: struct MOZ_STACK_CLASS ElementRuleProcessorData :
michael@0:                           public ElementDependentRuleProcessorData {
michael@0:   ElementRuleProcessorData(nsPresContext* aPresContext,
michael@0:                            mozilla::dom::Element* aElement, 
michael@0:                            nsRuleWalker* aRuleWalker,
michael@0:                            TreeMatchContext& aTreeMatchContext)
michael@0:     : ElementDependentRuleProcessorData(aPresContext, aElement, aRuleWalker,
michael@0:                                         aTreeMatchContext)
michael@0:   {
michael@0:     NS_PRECONDITION(aTreeMatchContext.mForStyling, "Styling here!");
michael@0:     NS_PRECONDITION(aRuleWalker, "Must have rule walker");
michael@0:   }
michael@0: };
michael@0: 
michael@0: struct MOZ_STACK_CLASS PseudoElementRuleProcessorData :
michael@0:                           public ElementDependentRuleProcessorData {
michael@0:   PseudoElementRuleProcessorData(nsPresContext* aPresContext,
michael@0:                                  mozilla::dom::Element* aParentElement,
michael@0:                                  nsRuleWalker* aRuleWalker,
michael@0:                                  nsCSSPseudoElements::Type aPseudoType,
michael@0:                                  TreeMatchContext& aTreeMatchContext,
michael@0:                                  mozilla::dom::Element* aPseudoElement)
michael@0:     : ElementDependentRuleProcessorData(aPresContext, aParentElement, aRuleWalker,
michael@0:                                         aTreeMatchContext),
michael@0:       mPseudoType(aPseudoType),
michael@0:       mPseudoElement(aPseudoElement)
michael@0:   {
michael@0:     NS_PRECONDITION(aPseudoType <
michael@0:                       nsCSSPseudoElements::ePseudo_PseudoElementCount,
michael@0:                     "invalid aPseudoType value");
michael@0:     NS_PRECONDITION(aTreeMatchContext.mForStyling, "Styling here!");
michael@0:     NS_PRECONDITION(aRuleWalker, "Must have rule walker");
michael@0:   }
michael@0: 
michael@0:   nsCSSPseudoElements::Type mPseudoType;
michael@0:   mozilla::dom::Element* const mPseudoElement; // weak ref
michael@0: };
michael@0: 
michael@0: struct MOZ_STACK_CLASS AnonBoxRuleProcessorData : public RuleProcessorData {
michael@0:   AnonBoxRuleProcessorData(nsPresContext* aPresContext,
michael@0:                            nsIAtom* aPseudoTag,
michael@0:                            nsRuleWalker* aRuleWalker)
michael@0:     : RuleProcessorData(aPresContext, aRuleWalker),
michael@0:       mPseudoTag(aPseudoTag)
michael@0:   {
michael@0:     NS_PRECONDITION(aPseudoTag, "Must have pseudo tag");
michael@0:     NS_PRECONDITION(aRuleWalker, "Must have rule walker");
michael@0:   }
michael@0: 
michael@0:   nsIAtom* mPseudoTag;
michael@0: };
michael@0: 
michael@0: #ifdef MOZ_XUL
michael@0: struct MOZ_STACK_CLASS XULTreeRuleProcessorData :
michael@0:                           public ElementDependentRuleProcessorData {
michael@0:   XULTreeRuleProcessorData(nsPresContext* aPresContext,
michael@0:                            mozilla::dom::Element* aParentElement,
michael@0:                            nsRuleWalker* aRuleWalker,
michael@0:                            nsIAtom* aPseudoTag,
michael@0:                            nsICSSPseudoComparator* aComparator,
michael@0:                            TreeMatchContext& aTreeMatchContext)
michael@0:     : ElementDependentRuleProcessorData(aPresContext, aParentElement,
michael@0:                                         aRuleWalker, aTreeMatchContext),
michael@0:       mPseudoTag(aPseudoTag),
michael@0:       mComparator(aComparator)
michael@0:   {
michael@0:     NS_PRECONDITION(aPseudoTag, "null pointer");
michael@0:     NS_PRECONDITION(aRuleWalker, "Must have rule walker");
michael@0:     NS_PRECONDITION(aComparator, "must have a comparator");
michael@0:     NS_PRECONDITION(aTreeMatchContext.mForStyling, "Styling here!");
michael@0:   }
michael@0: 
michael@0:   nsIAtom*                 mPseudoTag;
michael@0:   nsICSSPseudoComparator*  mComparator;
michael@0: };
michael@0: #endif
michael@0: 
michael@0: struct MOZ_STACK_CLASS StateRuleProcessorData :
michael@0:                           public ElementDependentRuleProcessorData {
michael@0:   StateRuleProcessorData(nsPresContext* aPresContext,
michael@0:                          mozilla::dom::Element* aElement,
michael@0:                          mozilla::EventStates aStateMask,
michael@0:                          TreeMatchContext& aTreeMatchContext)
michael@0:     : ElementDependentRuleProcessorData(aPresContext, aElement, nullptr,
michael@0:                                         aTreeMatchContext),
michael@0:       mStateMask(aStateMask)
michael@0:   {
michael@0:     NS_PRECONDITION(!aTreeMatchContext.mForStyling, "Not styling here!");
michael@0:   }
michael@0:   // |HasStateDependentStyle| for which state(s)?
michael@0:   // Constants defined in mozilla/EventStates.h .
michael@0:   const mozilla::EventStates mStateMask;
michael@0: };
michael@0: 
michael@0: struct MOZ_STACK_CLASS PseudoElementStateRuleProcessorData :
michael@0:                           public StateRuleProcessorData {
michael@0:   PseudoElementStateRuleProcessorData(nsPresContext* aPresContext,
michael@0:                                       mozilla::dom::Element* aElement,
michael@0:                                       mozilla::EventStates aStateMask,
michael@0:                                       nsCSSPseudoElements::Type aPseudoType,
michael@0:                                       TreeMatchContext& aTreeMatchContext,
michael@0:                                       mozilla::dom::Element* aPseudoElement)
michael@0:     : StateRuleProcessorData(aPresContext, aElement, aStateMask,
michael@0:                              aTreeMatchContext),
michael@0:       mPseudoType(aPseudoType),
michael@0:       mPseudoElement(aPseudoElement)
michael@0:   {
michael@0:     NS_PRECONDITION(!aTreeMatchContext.mForStyling, "Not styling here!");
michael@0:   }
michael@0: 
michael@0:   // We kind of want to inherit from both StateRuleProcessorData and
michael@0:   // PseudoElementRuleProcessorData.  Instead we've just copied those
michael@0:   // members from PseudoElementRuleProcessorData to this struct.
michael@0:   nsCSSPseudoElements::Type mPseudoType;
michael@0:   mozilla::dom::Element* const mPseudoElement; // weak ref
michael@0: };
michael@0: 
michael@0: struct MOZ_STACK_CLASS AttributeRuleProcessorData :
michael@0:                           public ElementDependentRuleProcessorData {
michael@0:   AttributeRuleProcessorData(nsPresContext* aPresContext,
michael@0:                              mozilla::dom::Element* aElement,
michael@0:                              nsIAtom* aAttribute,
michael@0:                              int32_t aModType,
michael@0:                              bool aAttrHasChanged,
michael@0:                              TreeMatchContext& aTreeMatchContext)
michael@0:     : ElementDependentRuleProcessorData(aPresContext, aElement, nullptr,
michael@0:                                         aTreeMatchContext),
michael@0:       mAttribute(aAttribute),
michael@0:       mModType(aModType),
michael@0:       mAttrHasChanged(aAttrHasChanged)
michael@0:   {
michael@0:     NS_PRECONDITION(!aTreeMatchContext.mForStyling, "Not styling here!");
michael@0:   }
michael@0:   nsIAtom* mAttribute; // |HasAttributeDependentStyle| for which attribute?
michael@0:   int32_t mModType;    // The type of modification (see nsIDOMMutationEvent).
michael@0:   bool mAttrHasChanged; // Whether the attribute has already changed.
michael@0: };
michael@0: 
michael@0: #endif /* !defined(nsRuleProcessorData_h_) */