Changeset 195293 in webkit

Timestamp:

Jan 19, 2016 9:39:20 AM (8 years ago)

Author:

Antti Koivisto

Message:

Selector checker should not mutate document and style
​https://bugs.webkit.org/show_bug.cgi?id=153205

Reviewed by Darin Adler.

Selector checker currently writes affected-by bits and similar directly to the document and style during selector
matching. This is confusing, complicated and wrong.

This patch changes SelectorChecker and SelectorCompiler to collect style relatationship metadata to a separate
data structure (currently part of SelectorChecker::CheckingContext) instead of changing the document and style
directly. The mutations are performed later outside selector checker.

• css/ElementRuleCollector.cpp:

(WebCore::ElementRuleCollector::ruleMatches):
(WebCore::ElementRuleCollector::commitStyleRelations):

Apply the relationship bit to elements and style.

(WebCore::ElementRuleCollector::collectMatchingRulesForList):

• css/ElementRuleCollector.h:
• css/SelectorChecker.cpp:

(WebCore::SelectorChecker::LocalContext::LocalContext):

LocalContext is now a separate data structure.

(WebCore::addStyleRelation):

Helper for recording new style relations. This is used where code mutated elements or style directly before.

(WebCore::isFirstChildElement):
(WebCore::isLastChildElement):
(WebCore::isFirstOfType):
(WebCore::isLastOfType):
(WebCore::countElementsBefore):
(WebCore::countElementsOfTypeBefore):
(WebCore::SelectorChecker::SelectorChecker):
(WebCore::SelectorChecker::match):
(WebCore::hasScrollbarPseudoElement):
(WebCore::localContextForParent):
(WebCore::SelectorChecker::matchRecursively):
(WebCore::attributeValueMatches):
(WebCore::anyAttributeMatches):
(WebCore::canMatchHoverOrActiveInQuirksMode):
(WebCore::tagMatches):
(WebCore::SelectorChecker::checkOne):
(WebCore::SelectorChecker::matchSelectorList):
(WebCore::SelectorChecker::checkScrollbarPseudoClass):
(WebCore::SelectorChecker::CheckingContextWithStatus::CheckingContextWithStatus): Deleted.
(WebCore::checkingContextForParent): Deleted.

• css/SelectorChecker.h:

(WebCore::SelectorChecker::CheckingContext::CheckingContext):

• css/SelectorCheckerTestFunctions.h:

(WebCore::isEnabled):
(WebCore::isMediaDocument):
(WebCore::isChecked):
(WebCore::isInRange):
(WebCore::isOutOfRange):

• css/StyleResolver.h:

(WebCore::checkRegionSelector):

• cssjit/SelectorCompiler.cpp:

(WebCore::SelectorCompiler::SelectorCodeGenerator::generateAddStyleRelationIfResolvingStyle):
(WebCore::SelectorCompiler::SelectorCodeGenerator::generateAddStyleRelation):

Helpers for generating code for recording new style relations. This is used where code mutated elements or style directly before.

(WebCore::SelectorCompiler::SelectorCodeGenerator::generateSelectorCheckerExcludingPseudoElements):
(WebCore::SelectorCompiler::SelectorCodeGenerator::generateDirectAdjacentTreeWalker):
(WebCore::SelectorCompiler::SelectorCodeGenerator::generateIndirectAdjacentTreeWalker):
(WebCore::SelectorCompiler::addStyleRelationElementFunction):
(WebCore::SelectorCompiler::SelectorCodeGenerator::jumpIfNoPreviousAdjacentElement):
(WebCore::SelectorCompiler::SelectorCodeGenerator::moduloIsZero):
(WebCore::SelectorCompiler::SelectorCodeGenerator::linkFailures):
(WebCore::SelectorCompiler::SelectorCodeGenerator::generateElementMatching):
(WebCore::SelectorCompiler::SelectorCodeGenerator::generateContextFunctionCallTest):
(WebCore::SelectorCompiler::elementIsActive):
(WebCore::SelectorCompiler::SelectorCodeGenerator::generateElementIsActive):
(WebCore::SelectorCompiler::jumpIfElementIsNotEmpty):
(WebCore::SelectorCompiler::SelectorCodeGenerator::generateElementIsEmpty):
(WebCore::SelectorCompiler::SelectorCodeGenerator::generateElementIsFirstChild):
(WebCore::SelectorCompiler::elementIsHovered):
(WebCore::SelectorCompiler::SelectorCodeGenerator::generateElementIsHovered):
(WebCore::SelectorCompiler::SelectorCodeGenerator::generateElementIsInLanguage):
(WebCore::SelectorCompiler::SelectorCodeGenerator::generateElementIsLastChild):
(WebCore::SelectorCompiler::SelectorCodeGenerator::generateElementIsOnlyChild):
(WebCore::SelectorCompiler::makeContextStyleUniqueIfNecessaryAndTestIsPlaceholderShown):
(WebCore::SelectorCompiler::isPlaceholderShown):
(WebCore::SelectorCompiler::SelectorCodeGenerator::generateElementHasPlaceholderShown):
(WebCore::SelectorCompiler::SelectorCodeGenerator::generateElementIsLink):
(WebCore::SelectorCompiler::nthFilterIsAlwaysSatisified):
(WebCore::SelectorCompiler::SelectorCodeGenerator::generateElementIsNthChild):
(WebCore::SelectorCompiler::SelectorCodeGenerator::generateElementIsNthChildOf):
(WebCore::SelectorCompiler::SelectorCodeGenerator::generateElementIsNthLastChild):
(WebCore::SelectorCompiler::SelectorCodeGenerator::generateElementIsNthLastChildOf):
(WebCore::SelectorCompiler::SelectorCodeGenerator::generateMarkPseudoStyleForPseudoElement):
(WebCore::SelectorCompiler::SelectorCodeGenerator::addFlagsToElementStyleFromContext): Deleted.
(WebCore::SelectorCompiler::setNodeFlag): Deleted.
(WebCore::SelectorCompiler::SelectorCodeGenerator::markElementIfResolvingStyle): Deleted.
(WebCore::SelectorCompiler::setFirstChildState): Deleted.
(WebCore::SelectorCompiler::elementIsActiveForStyleResolution): Deleted.
(WebCore::SelectorCompiler::setElementStyleIsAffectedByEmpty): Deleted.
(WebCore::SelectorCompiler::setElementStyleFromContextIsAffectedByEmptyAndUpdateRenderStyleIfNecessary): Deleted.
(WebCore::SelectorCompiler::elementIsHoveredForStyleResolution): Deleted.
(WebCore::SelectorCompiler::setLastChildState): Deleted.
(WebCore::SelectorCompiler::setOnlyChildState): Deleted.
(WebCore::SelectorCompiler::makeElementStyleUniqueIfNecessaryAndTestIsPlaceholderShown): Deleted.
(WebCore::SelectorCompiler::setElementChildIndex): Deleted.
(WebCore::SelectorCompiler::setChildrenAffectedByBackwardPositionalRules): Deleted.
(WebCore::SelectorCompiler::setParentAffectedByLastChildOf): Deleted.

• dom/SelectorQuery.cpp:

(WebCore::SelectorDataList::selectorMatches):
(WebCore::SelectorDataList::selectorClosest):
(WebCore::SelectorDataList::matches):

• inspector/InspectorCSSAgent.cpp:

(WebCore::InspectorCSSAgent::buildArrayForMatchedRuleList):

• inspector/InspectorStyleSheet.cpp:

(WebCore::buildObjectForSelectorHelper):

Location:

trunk/Source/WebCore

Files:

• ChangeLog (modified) (1 diff)
• css/ElementRuleCollector.cpp (modified) (3 diffs)
• css/ElementRuleCollector.h (modified) (1 diff)
• css/SelectorChecker.cpp (modified) (49 diffs)
• css/SelectorChecker.h (modified) (3 diffs)
• css/SelectorCheckerTestFunctions.h (modified) (2 diffs)
• css/StyleResolver.h (modified) (1 diff)
• cssjit/SelectorCompiler.cpp (modified) (39 diffs)
• dom/SelectorQuery.cpp (modified) (2 diffs)
• inspector/InspectorCSSAgent.cpp (modified) (1 diff)
• inspector/InspectorStyleSheet.cpp (modified) (1 diff)
• rendering/style/RenderStyleConstants.h (modified) (1 diff)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2016-01-18  Antti Koivisto  <antti@apple.com>
+
+        Selector checker should not mutate document and style
+        https://bugs.webkit.org/show_bug.cgi?id=153205
+
+        Reviewed by Darin Adler.
+
+        Selector checker currently writes affected-by bits and similar directly to the document and style during selector
+        matching. This is confusing, complicated and wrong.
+
+        This patch changes SelectorChecker and SelectorCompiler to collect style relatationship metadata to a separate
+        data structure (currently part of SelectorChecker::CheckingContext) instead of changing the document and style
+        directly. The mutations are performed later outside selector checker.
+
+        * css/ElementRuleCollector.cpp:
+        (WebCore::ElementRuleCollector::ruleMatches):
+        (WebCore::ElementRuleCollector::commitStyleRelations):
+
+            Apply the relationship bit to elements and style.
+
+        (WebCore::ElementRuleCollector::collectMatchingRulesForList):
+        * css/ElementRuleCollector.h:
+        * css/SelectorChecker.cpp:
+        (WebCore::SelectorChecker::LocalContext::LocalContext):
+
+            LocalContext is now a separate data structure.
+
+        (WebCore::addStyleRelation):
+
+            Helper for recording new style relations. This is used where code mutated elements or style directly before.
+
+        (WebCore::isFirstChildElement):
+        (WebCore::isLastChildElement):
+        (WebCore::isFirstOfType):
+        (WebCore::isLastOfType):
+        (WebCore::countElementsBefore):
+        (WebCore::countElementsOfTypeBefore):
+        (WebCore::SelectorChecker::SelectorChecker):
+        (WebCore::SelectorChecker::match):
+        (WebCore::hasScrollbarPseudoElement):
+        (WebCore::localContextForParent):
+        (WebCore::SelectorChecker::matchRecursively):
+        (WebCore::attributeValueMatches):
+        (WebCore::anyAttributeMatches):
+        (WebCore::canMatchHoverOrActiveInQuirksMode):
+        (WebCore::tagMatches):
+        (WebCore::SelectorChecker::checkOne):
+        (WebCore::SelectorChecker::matchSelectorList):
+        (WebCore::SelectorChecker::checkScrollbarPseudoClass):
+        (WebCore::SelectorChecker::CheckingContextWithStatus::CheckingContextWithStatus): Deleted.
+        (WebCore::checkingContextForParent): Deleted.
+        * css/SelectorChecker.h:
+        (WebCore::SelectorChecker::CheckingContext::CheckingContext):
+        * css/SelectorCheckerTestFunctions.h:
+        (WebCore::isEnabled):
+        (WebCore::isMediaDocument):
+        (WebCore::isChecked):
+        (WebCore::isInRange):
+        (WebCore::isOutOfRange):
+        * css/StyleResolver.h:
+        (WebCore::checkRegionSelector):
+        * cssjit/SelectorCompiler.cpp:
+        (WebCore::SelectorCompiler::SelectorCodeGenerator::generateAddStyleRelationIfResolvingStyle):
+        (WebCore::SelectorCompiler::SelectorCodeGenerator::generateAddStyleRelation):
+
+            Helpers for generating code for recording new style relations. This is used where code mutated elements or style directly before.
+
+        (WebCore::SelectorCompiler::SelectorCodeGenerator::generateSelectorCheckerExcludingPseudoElements):
+        (WebCore::SelectorCompiler::SelectorCodeGenerator::generateDirectAdjacentTreeWalker):
+        (WebCore::SelectorCompiler::SelectorCodeGenerator::generateIndirectAdjacentTreeWalker):
+        (WebCore::SelectorCompiler::addStyleRelationElementFunction):
+        (WebCore::SelectorCompiler::SelectorCodeGenerator::jumpIfNoPreviousAdjacentElement):
+        (WebCore::SelectorCompiler::SelectorCodeGenerator::moduloIsZero):
+        (WebCore::SelectorCompiler::SelectorCodeGenerator::linkFailures):
+        (WebCore::SelectorCompiler::SelectorCodeGenerator::generateElementMatching):
+        (WebCore::SelectorCompiler::SelectorCodeGenerator::generateContextFunctionCallTest):
+        (WebCore::SelectorCompiler::elementIsActive):
+        (WebCore::SelectorCompiler::SelectorCodeGenerator::generateElementIsActive):
+        (WebCore::SelectorCompiler::jumpIfElementIsNotEmpty):
+        (WebCore::SelectorCompiler::SelectorCodeGenerator::generateElementIsEmpty):
+        (WebCore::SelectorCompiler::SelectorCodeGenerator::generateElementIsFirstChild):
+        (WebCore::SelectorCompiler::elementIsHovered):
+        (WebCore::SelectorCompiler::SelectorCodeGenerator::generateElementIsHovered):
+        (WebCore::SelectorCompiler::SelectorCodeGenerator::generateElementIsInLanguage):
+        (WebCore::SelectorCompiler::SelectorCodeGenerator::generateElementIsLastChild):
+        (WebCore::SelectorCompiler::SelectorCodeGenerator::generateElementIsOnlyChild):
+        (WebCore::SelectorCompiler::makeContextStyleUniqueIfNecessaryAndTestIsPlaceholderShown):
+        (WebCore::SelectorCompiler::isPlaceholderShown):
+        (WebCore::SelectorCompiler::SelectorCodeGenerator::generateElementHasPlaceholderShown):
+        (WebCore::SelectorCompiler::SelectorCodeGenerator::generateElementIsLink):
+        (WebCore::SelectorCompiler::nthFilterIsAlwaysSatisified):
+        (WebCore::SelectorCompiler::SelectorCodeGenerator::generateElementIsNthChild):
+        (WebCore::SelectorCompiler::SelectorCodeGenerator::generateElementIsNthChildOf):
+        (WebCore::SelectorCompiler::SelectorCodeGenerator::generateElementIsNthLastChild):
+        (WebCore::SelectorCompiler::SelectorCodeGenerator::generateElementIsNthLastChildOf):
+        (WebCore::SelectorCompiler::SelectorCodeGenerator::generateMarkPseudoStyleForPseudoElement):
+        (WebCore::SelectorCompiler::SelectorCodeGenerator::addFlagsToElementStyleFromContext): Deleted.
+        (WebCore::SelectorCompiler::setNodeFlag): Deleted.
+        (WebCore::SelectorCompiler::SelectorCodeGenerator::markElementIfResolvingStyle): Deleted.
+        (WebCore::SelectorCompiler::setFirstChildState): Deleted.
+        (WebCore::SelectorCompiler::elementIsActiveForStyleResolution): Deleted.
+        (WebCore::SelectorCompiler::setElementStyleIsAffectedByEmpty): Deleted.
+        (WebCore::SelectorCompiler::setElementStyleFromContextIsAffectedByEmptyAndUpdateRenderStyleIfNecessary): Deleted.
+        (WebCore::SelectorCompiler::elementIsHoveredForStyleResolution): Deleted.
+        (WebCore::SelectorCompiler::setLastChildState): Deleted.
+        (WebCore::SelectorCompiler::setOnlyChildState): Deleted.
+        (WebCore::SelectorCompiler::makeElementStyleUniqueIfNecessaryAndTestIsPlaceholderShown): Deleted.
+        (WebCore::SelectorCompiler::setElementChildIndex): Deleted.
+        (WebCore::SelectorCompiler::setChildrenAffectedByBackwardPositionalRules): Deleted.
+        (WebCore::SelectorCompiler::setParentAffectedByLastChildOf): Deleted.
+        * dom/SelectorQuery.cpp:
+        (WebCore::SelectorDataList::selectorMatches):
+        (WebCore::SelectorDataList::selectorClosest):
+        (WebCore::SelectorDataList::matches):
+        * inspector/InspectorCSSAgent.cpp:
+        (WebCore::InspectorCSSAgent::buildArrayForMatchedRuleList):
+        * inspector/InspectorStyleSheet.cpp:
+        (WebCore::buildObjectForSelectorHelper):
+
 2016-01-19  Carlos Garcia Campos  <cgarcia@igalia.com>
 

trunk/Source/WebCore/css/ElementRuleCollector.cpp

@@ -38 +38 @@
 #include "HTMLElement.h"
 #include "InspectorInstrumentation.h"
+#include "NodeRenderStyle.h"
 #include "RenderRegion.h"
 #include "SVGElement.h"
@@ -329 +330 @@
 
     SelectorChecker::CheckingContext context(m_mode);
-    context.elementStyle = m_style;
     context.pseudoId = m_pseudoStyleRequest.pseudoId;
     context.scrollbar = m_pseudoStyleRequest.scrollbar;
     context.scrollbarPart = m_pseudoStyleRequest.scrollbarPart;
 
+    bool selectorMatches;
 #if ENABLE(CSS_SELECTOR_JIT)
     if (compiledSelectorChecker) {
@@ -343 +344 @@
         ruleData.compiledSelectorUsed();
 #endif
-        return selectorChecker(&m_element, &context, &specificity);
-    }
+        selectorMatches = selectorChecker(&m_element, &context, &specificity);
+    } else
 #endif // ENABLE(CSS_SELECTOR_JIT)
-
-    // Slow path.
-    SelectorChecker selectorChecker(m_element.document());
-    return selectorChecker.match(ruleData.selector(), &m_element, context, specificity);
+    {
+        // Slow path.
+        SelectorChecker selectorChecker(m_element.document());
+        selectorMatches = selectorChecker.match(*ruleData.selector(), m_element, context, specificity);
+    }
+
+    commitStyleRelations(context.styleRelations);
+
+    if (context.pseudoIDSet)
+        m_style->setHasPseudoStyles(context.pseudoIDSet);
+
+    return selectorMatches;
+}
+
+// FIXME: Rule collector should not be doing mutations. Move this somewhere else.
+void ElementRuleCollector::commitStyleRelations(const SelectorChecker::StyleRelations& styleRelations)
+{
+    for (auto& relation : styleRelations) {
+        switch (relation.type) {
+        case SelectorChecker::StyleRelation::AffectedByActive:
+            if (&relation.element == &m_element)
+                m_style->setAffectedByActive();
+            else
+                relation.element.setChildrenAffectedByActive();
+            break;
+        case SelectorChecker::StyleRelation::AffectedByDrag:
+            if (&relation.element == &m_element)
+                m_style->setAffectedByDrag();
+            else
+                relation.element.setChildrenAffectedByDrag();
+            break;
+        case SelectorChecker::StyleRelation::AffectedByEmpty:
+            relation.element.setStyleAffectedByEmpty();
+            if (&relation.element == &m_element)
+                m_style->setEmptyState(relation.value);
+            break;
+        case SelectorChecker::StyleRelation::AffectedByHover:
+            if (&relation.element == &m_element)
+                m_style->setAffectedByHover();
+            else
+                relation.element.setChildrenAffectedByHover();
+            break;
+        case SelectorChecker::StyleRelation::AffectedByPreviousSibling:
+            relation.element.setStyleIsAffectedByPreviousSibling();
+            break;
+        case SelectorChecker::StyleRelation::AffectsNextSibling:
+            relation.element.setAffectsNextSiblingElementStyle();
+            break;
+        case SelectorChecker::StyleRelation::ChildrenAffectedByBackwardPositionalRules:
+            relation.element.setChildrenAffectedByBackwardPositionalRules();
+            break;
+        case SelectorChecker::StyleRelation::ChildrenAffectedByFirstChildRules:
+            relation.element.setChildrenAffectedByFirstChildRules();
+            break;
+        case SelectorChecker::StyleRelation::ChildrenAffectedByPropertyBasedBackwardPositionalRules:
+            relation.element.setChildrenAffectedByBackwardPositionalRules();
+            relation.element.setChildrenAffectedByPropertyBasedBackwardPositionalRules();
+            break;
+        case SelectorChecker::StyleRelation::ChildrenAffectedByLastChildRules:
+            relation.element.setChildrenAffectedByLastChildRules();
+            break;
+        case SelectorChecker::StyleRelation::FirstChild:
+            if (&relation.element == &m_element)
+                m_style->setFirstChildState();
+            else if (auto* style = relation.element.renderStyle())
+                style->setFirstChildState();
+            break;
+        case SelectorChecker::StyleRelation::LastChild:
+            if (&relation.element == &m_element)
+                m_style->setLastChildState();
+            else if (auto* style = relation.element.renderStyle())
+                style->setLastChildState();
+            break;
+        case SelectorChecker::StyleRelation::NthChildIndex:
+            relation.element.setChildIndex(relation.value);
+            break;
+        case SelectorChecker::StyleRelation::Unique:
+            if (&relation.element == &m_element)
+                m_style->setUnique();
+            else if (auto* style = relation.element.renderStyle())
+                style->setUnique();
+            break;
+        }
+    }
 }
 

trunk/Source/WebCore/css/ElementRuleCollector.h

@@ -85 +85 @@
     void addMatchedRule(const MatchedRule&);
 
+    void commitStyleRelations(const SelectorChecker::StyleRelations&);
+
     Element& m_element;
     RenderStyle* m_style;

trunk/Source/WebCore/css/SelectorChecker.cpp

@@ -3 +3 @@
  *           (C) 2004-2005 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2006, 2007 Nicholas Shanks (webkit@nickshanks.com)
- * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014 Apple Inc. All rights reserved.
+ * Copyright (C) 2005-2016 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
  * Copyright (C) 2007, 2008 Eric Seidel <eric@webkit.org>
@@ -47 +47 @@
 #include "HTMLStyleElement.h"
 #include "InspectorInstrumentation.h"
-#include "NodeRenderStyle.h"
 #include "Page.h"
 #include "RenderElement.h"
-#include "RenderStyle.h"
 #include "SelectorCheckerTestFunctions.h"
 #include "ShadowRoot.h"
@@ -64 +62 @@
 };
 
-struct SelectorChecker::CheckingContextWithStatus : public SelectorChecker::CheckingContext {
-    CheckingContextWithStatus(const SelectorChecker::CheckingContext& checkingContext, const CSSSelector* selector, Element* element)
-        : SelectorChecker::CheckingContext(checkingContext)
-        , selector(selector)
-        , element(element)
-        , visitedMatchType(resolvingMode == SelectorChecker::Mode::QueryingRules ? VisitedMatchType::Disabled : VisitedMatchType::Enabled)
-        , firstSelectorOfTheFragment(selector)
-        , inFunctionalPseudoClass(false)
-        , pseudoElementEffective(true)
-        , hasScrollbarPseudo(false)
-        , hasSelectionPseudo(false)
+struct SelectorChecker::LocalContext {
+    LocalContext(const CSSSelector& selector, const Element& element, VisitedMatchType visitedMatchType, PseudoId pseudoId)
+        : selector(&selector)
+        , element(&element)
+        , visitedMatchType(visitedMatchType)
+        , firstSelectorOfTheFragment(&selector)
+        , pseudoId(pseudoId)
     { }
 
     const CSSSelector* selector;
-    Element* element;
+    const Element* element;
     VisitedMatchType visitedMatchType;
     const CSSSelector* firstSelectorOfTheFragment;
-    bool inFunctionalPseudoClass;
-    bool pseudoElementEffective;
-    bool hasScrollbarPseudo;
-    bool hasSelectionPseudo;
+    PseudoId pseudoId;
+    bool isMatchElement { true };
+    bool inFunctionalPseudoClass { false };
+    bool pseudoElementEffective { true };
+    bool hasScrollbarPseudo { false };
+    bool hasSelectionPseudo { false };
+
 };
 
+static inline void addStyleRelation(SelectorChecker::CheckingContext& checkingContext, const Element& element, SelectorChecker::StyleRelation::Type type, unsigned value = 1)
+{
+    ASSERT(value == 1 || type == SelectorChecker::StyleRelation::NthChildIndex || type == SelectorChecker::StyleRelation::AffectedByEmpty);
+    if (checkingContext.resolvingMode != SelectorChecker::Mode::ResolvingStyle)
+        return;
+    checkingContext.styleRelations.append({ const_cast<Element&>(element), type, value });
+}
+
 static inline bool isFirstChildElement(const Element& element)
 {
@@ -97 +102 @@
 }
 
-static inline bool isFirstOfType(Element& element, const QualifiedName& type, bool isResolvingStyle)
-{
-    for (Element* sibling = ElementTraversal::previousSibling(element); sibling; sibling = ElementTraversal::previousSibling(*sibling)) {
-        if (isResolvingStyle)
-            sibling->setAffectsNextSiblingElementStyle();
+static inline bool isFirstOfType(SelectorChecker::CheckingContext& checkingContext, const Element& element, const QualifiedName& type)
+{
+    for (const Element* sibling = ElementTraversal::previousSibling(element); sibling; sibling = ElementTraversal::previousSibling(*sibling)) {
+        addStyleRelation(checkingContext, *sibling, SelectorChecker::StyleRelation::AffectsNextSibling);
+
         if (sibling->hasTagName(type))
             return false;
@@ -117 +122 @@
 }
 
-static inline int countElementsBefore(Element& element, bool isResolvingStyle)
+static inline int countElementsBefore(SelectorChecker::CheckingContext& checkingContext, const Element& element)
 {
     int count = 0;
-    for (Element* sibling = ElementTraversal::previousSibling(element); sibling; sibling = ElementTraversal::previousSibling(*sibling)) {
-        if (isResolvingStyle)
-            sibling->setAffectsNextSiblingElementStyle();
+    for (const Element* sibling = ElementTraversal::previousSibling(element); sibling; sibling = ElementTraversal::previousSibling(*sibling)) {
+
+        addStyleRelation(checkingContext, *sibling, SelectorChecker::StyleRelation::AffectsNextSibling);
 
         unsigned index = sibling->childIndex();
@@ -134 +139 @@
 }
 
-static inline int countElementsOfTypeBefore(Element& element, const QualifiedName& type, bool isResolvingStyle)
+static inline int countElementsOfTypeBefore(SelectorChecker::CheckingContext& checkingContext, const Element& element, const QualifiedName& type)
 {
     int count = 0;
-    for (Element* sibling = ElementTraversal::previousSibling(element); sibling; sibling = ElementTraversal::previousSibling(*sibling)) {
-        if (isResolvingStyle)
-            sibling->setAffectsNextSiblingElementStyle();
+    for (const Element* sibling = ElementTraversal::previousSibling(element); sibling; sibling = ElementTraversal::previousSibling(*sibling)) {
+        addStyleRelation(checkingContext, *sibling, SelectorChecker::StyleRelation::AffectsNextSibling);
 
         if (sibling->hasTagName(type))
@@ -171 +175 @@
 }
 
-bool SelectorChecker::match(const CSSSelector* selector, Element* element, const CheckingContext& providedContext, unsigned& specificity) const
+bool SelectorChecker::match(const CSSSelector& selector, const Element& element, CheckingContext& checkingContext, unsigned& specificity) const
 {
     specificity = 0;
 
-    CheckingContextWithStatus context(providedContext, selector, element);
+    LocalContext context(selector, element, checkingContext.resolvingMode == SelectorChecker::Mode::QueryingRules ? VisitedMatchType::Disabled : VisitedMatchType::Enabled, checkingContext.pseudoId);
     PseudoIdSet pseudoIdSet;
-    MatchResult result = matchRecursively(context, pseudoIdSet, specificity);
+    MatchResult result = matchRecursively(checkingContext, context, pseudoIdSet, specificity);
     if (result.match != Match::SelectorMatches)
         return false;
-    if (context.pseudoId != NOPSEUDO && !pseudoIdSet.has(context.pseudoId))
+    if (checkingContext.pseudoId != NOPSEUDO && !pseudoIdSet.has(checkingContext.pseudoId))
         return false;
 
-    if (context.pseudoId == NOPSEUDO && pseudoIdSet) {
+    if (checkingContext.pseudoId == NOPSEUDO && pseudoIdSet) {
         PseudoIdSet publicPseudoIdSet = pseudoIdSet & PseudoIdSet::fromMask(PUBLIC_PSEUDOID_MASK);
-        if (context.resolvingMode == Mode::ResolvingStyle && publicPseudoIdSet)
-            context.elementStyle->setHasPseudoStyles(publicPseudoIdSet);
+        if (checkingContext.resolvingMode == Mode::ResolvingStyle && publicPseudoIdSet)
+            checkingContext.pseudoIDSet = publicPseudoIdSet;
 
         // When ignoring virtual pseudo elements, the context's pseudo should also be NOPSEUDO but that does
         // not cause a failure.
-        return context.resolvingMode == Mode::CollectingRulesIgnoringVirtualPseudoElements || result.matchType == MatchType::Element;
+        return checkingContext.resolvingMode == Mode::CollectingRulesIgnoringVirtualPseudoElements || result.matchType == MatchType::Element;
     }
     return true;
@@ -206 +210 @@
 }
 
-static SelectorChecker::CheckingContextWithStatus checkingContextForParent(const SelectorChecker::CheckingContextWithStatus& context)
-{
-    SelectorChecker::CheckingContextWithStatus updatedContext(context);
+static SelectorChecker::LocalContext localContextForParent(const SelectorChecker::LocalContext& context)
+{
+    SelectorChecker::LocalContext updatedContext(context);
     // Disable :visited matching when we see the first link.
     if (context.element->isLink())
         updatedContext.visitedMatchType = VisitedMatchType::Disabled;
     updatedContext.element = context.element->parentElement();
+    updatedContext.isMatchElement = false;
     return updatedContext;
 }
@@ -222 +227 @@
 // * SelectorFailsAllSiblings - the selector fails for e and any sibling of e
 // * SelectorFailsCompletely  - the selector fails for e and any sibling or ancestor of e
-SelectorChecker::MatchResult SelectorChecker::matchRecursively(const CheckingContextWithStatus& context, PseudoIdSet& dynamicPseudoIdSet, unsigned& specificity) const
+SelectorChecker::MatchResult SelectorChecker::matchRecursively(CheckingContext& checkingContext, const LocalContext& context, PseudoIdSet& dynamicPseudoIdSet, unsigned& specificity) const
 {
     MatchType matchType = MatchType::Element;
 
     // The first selector has to match.
-    if (!checkOne(context, dynamicPseudoIdSet, matchType, specificity))
+    if (!checkOne(checkingContext, context, dynamicPseudoIdSet, matchType, specificity))
         return MatchResult::fails(Match::SelectorFailsLocally);
 
@@ -248 +253 @@
                 return MatchResult::fails(Match::SelectorFailsCompletely);
 
-            if (context.resolvingMode == Mode::QueryingRules)
+            if (checkingContext.resolvingMode == Mode::QueryingRules)
                 return MatchResult::fails(Match::SelectorFailsCompletely);
 
@@ -266 +271 @@
         return MatchResult::matches(matchType);
 
-    CheckingContextWithStatus nextContext(context);
+    LocalContext nextContext(context);
     nextContext.selector = historySelector;
 
@@ -281 +286 @@
         // Virtual pseudo element is only effective in the rightmost fragment.
         nextContext.pseudoElementEffective = false;
+        nextContext.isMatchElement = false;
     }
 
     switch (relation) {
     case CSSSelector::Descendant:
-        nextContext = checkingContextForParent(nextContext);
+        nextContext = localContextForParent(nextContext);
         nextContext.firstSelectorOfTheFragment = nextContext.selector;
-        nextContext.elementStyle = nullptr;
-        for (; nextContext.element; nextContext = checkingContextForParent(nextContext)) {
+        for (; nextContext.element; nextContext = localContextForParent(nextContext)) {
             PseudoIdSet ignoreDynamicPseudo;
             unsigned descendantsSpecificity = 0;
-            MatchResult result = matchRecursively(nextContext, ignoreDynamicPseudo, descendantsSpecificity);
+            MatchResult result = matchRecursively(checkingContext, nextContext, ignoreDynamicPseudo, descendantsSpecificity);
             ASSERT(!nextContext.pseudoElementEffective && !ignoreDynamicPseudo);
 
@@ -304 +309 @@
     case CSSSelector::Child:
         {
-            nextContext = checkingContextForParent(nextContext);
+            nextContext = localContextForParent(nextContext);
             if (!nextContext.element)
                 return MatchResult::fails(Match::SelectorFailsCompletely);
             nextContext.firstSelectorOfTheFragment = nextContext.selector;
-            nextContext.elementStyle = nullptr;
             PseudoIdSet ignoreDynamicPseudo;
             unsigned childSpecificity = 0;
-            MatchResult result = matchRecursively(nextContext, ignoreDynamicPseudo, childSpecificity);
+            MatchResult result = matchRecursively(checkingContext, nextContext, ignoreDynamicPseudo, childSpecificity);
             ASSERT(!nextContext.pseudoElementEffective && !ignoreDynamicPseudo);
 
@@ -324 +328 @@
     case CSSSelector::DirectAdjacent:
         {
-            if (context.resolvingMode == Mode::ResolvingStyle)
-                context.element->setStyleIsAffectedByPreviousSibling();
+            addStyleRelation(checkingContext, *context.element, StyleRelation::AffectedByPreviousSibling);
 
             Element* previousElement = context.element->previousElementSibling();
             if (!previousElement)
                 return MatchResult::fails(Match::SelectorFailsAllSiblings);
-            if (context.resolvingMode == Mode::ResolvingStyle)
-                previousElement->setAffectsNextSiblingElementStyle();
+
+            addStyleRelation(checkingContext, *previousElement, StyleRelation::AffectsNextSibling);
+
             nextContext.element = previousElement;
             nextContext.firstSelectorOfTheFragment = nextContext.selector;
-            nextContext.elementStyle = nullptr;
             PseudoIdSet ignoreDynamicPseudo;
             unsigned adjacentSpecificity = 0;
-            MatchResult result = matchRecursively(nextContext, ignoreDynamicPseudo, adjacentSpecificity);
+            MatchResult result = matchRecursively(checkingContext, nextContext, ignoreDynamicPseudo, adjacentSpecificity);
             ASSERT(!nextContext.pseudoElementEffective && !ignoreDynamicPseudo);
 
@@ -346 +349 @@
         }
     case CSSSelector::IndirectAdjacent:
-        if (context.resolvingMode == Mode::ResolvingStyle)
-            context.element->setStyleIsAffectedByPreviousSibling();
+        addStyleRelation(checkingContext, *context.element, StyleRelation::AffectedByPreviousSibling);
+
         nextContext.element = context.element->previousElementSibling();
         nextContext.firstSelectorOfTheFragment = nextContext.selector;
-        nextContext.elementStyle = nullptr;
         for (; nextContext.element; nextContext.element = nextContext.element->previousElementSibling()) {
-            if (context.resolvingMode == Mode::ResolvingStyle)
-                nextContext.element->setAffectsNextSiblingElementStyle();
+            addStyleRelation(checkingContext, *nextContext.element, StyleRelation::AffectsNextSibling);
 
             PseudoIdSet ignoreDynamicPseudo;
             unsigned indirectAdjacentSpecificity = 0;
-            MatchResult result = matchRecursively(nextContext, ignoreDynamicPseudo, indirectAdjacentSpecificity);
+            MatchResult result = matchRecursively(checkingContext, nextContext, ignoreDynamicPseudo, indirectAdjacentSpecificity);
             ASSERT(!nextContext.pseudoElementEffective && !ignoreDynamicPseudo);
 
@@ -375 +376 @@
             nextContext.hasScrollbarPseudo = hasScrollbarPseudoElement(dynamicPseudoIdSet);
             nextContext.hasSelectionPseudo = dynamicPseudoIdSet.has(SELECTION);
-            if ((context.elementStyle || context.resolvingMode == Mode::CollectingRules) && dynamicPseudoIdSet
+            if ((context.isMatchElement || checkingContext.resolvingMode == Mode::CollectingRules) && dynamicPseudoIdSet
                 && !nextContext.hasSelectionPseudo
                 && !(nextContext.hasScrollbarPseudo && nextContext.selector->match() == CSSSelector::PseudoClass))
@@ -381 +382 @@
 
             unsigned subselectorSpecificity = 0;
-            MatchResult result = matchRecursively(nextContext, dynamicPseudoIdSet, subselectorSpecificity);
+            MatchResult result = matchRecursively(checkingContext, nextContext, dynamicPseudoIdSet, subselectorSpecificity);
 
             if (result.match == Match::SelectorMatches)
@@ -395 +396 @@
             nextContext.element = shadowHostNode;
             nextContext.firstSelectorOfTheFragment = nextContext.selector;
-            nextContext.elementStyle = nullptr;
             PseudoIdSet ignoreDynamicPseudo;
             unsigned shadowDescendantSpecificity = 0;
-            MatchResult result = matchRecursively(nextContext, ignoreDynamicPseudo, shadowDescendantSpecificity);
+            MatchResult result = matchRecursively(checkingContext, nextContext, ignoreDynamicPseudo, shadowDescendantSpecificity);
 
             if (result.match == Match::SelectorMatches)
@@ -505 +505 @@
 }
 
-static bool anyAttributeMatches(Element* element, const CSSSelector* selector, const QualifiedName& selectorAttr, bool caseSensitive)
+static bool anyAttributeMatches(const Element* element, const CSSSelector* selector, const QualifiedName& selectorAttr, bool caseSensitive)
 {
     ASSERT(element->hasAttributesWithoutUpdate());
@@ -519 +519 @@
 }
 
-static bool canMatchHoverOrActiveInQuirksMode(const SelectorChecker::CheckingContextWithStatus& context)
+static bool canMatchHoverOrActiveInQuirksMode(const SelectorChecker::LocalContext& context)
 {
     // For quirks mode, follow this: http://quirks.spec.whatwg.org/#the-:active-and-:hover-quirk
@@ -589 +589 @@
 }
 
-bool SelectorChecker::checkOne(const CheckingContextWithStatus& context, PseudoIdSet& dynamicPseudoIdSet, MatchType& matchType, unsigned& specificity) const
-{
-    Element* const & element = context.element;
+bool SelectorChecker::checkOne(CheckingContext& checkingContext, const LocalContext& context, PseudoIdSet& dynamicPseudoIdSet, MatchType& matchType, unsigned& specificity) const
+{
+    const Element* element = context.element;
     const CSSSelector* const & selector = context.selector;
     ASSERT(element);
@@ -627 +627 @@
 
             for (const CSSSelector* subselector = selectorList->first(); subselector; subselector = CSSSelectorList::next(subselector)) {
-                CheckingContextWithStatus subcontext(context);
+                LocalContext subcontext(context);
                 subcontext.inFunctionalPseudoClass = true;
                 subcontext.pseudoElementEffective = false;
@@ -635 +635 @@
 
                 unsigned ignoredSpecificity;
-                if (matchRecursively(subcontext, ignoreDynamicPseudo, ignoredSpecificity).match == Match::SelectorMatches) {
+                if (matchRecursively(checkingContext, subcontext, ignoreDynamicPseudo, ignoredSpecificity).match == Match::SelectorMatches) {
                     ASSERT(!ignoreDynamicPseudo);
                     return false;
@@ -644 +644 @@
             // CSS scrollbars match a specific subset of pseudo classes, and they have specialized rules for each
             // (since there are no elements involved except with window-inactive).
-            return checkScrollbarPseudoClass(context, selector);
+            return checkScrollbarPseudoClass(checkingContext, *context.element, selector);
         }
 
@@ -668 +668 @@
                     }
                 }
-                if (context.resolvingMode == Mode::ResolvingStyle) {
-                    element->setStyleAffectedByEmpty();
-                    if (context.elementStyle)
-                        context.elementStyle->setEmptyState(result);
-                }
+                addStyleRelation(checkingContext, *context.element, StyleRelation::AffectedByEmpty, result);
+
                 return result;
             }
         case CSSSelector::PseudoClassFirstChild:
             // first-child matches the first child that is an element
-            if (Element* parentElement = element->parentElement()) {
-                bool result = isFirstChildElement(*element);
-                if (context.resolvingMode == Mode::ResolvingStyle) {
-                    RenderStyle* childStyle = context.elementStyle ? context.elementStyle : element->renderStyle();
-                    parentElement->setChildrenAffectedByFirstChildRules();
-                    if (result && childStyle)
-                        childStyle->setFirstChildState();
-                }
-                return result;
+            if (const Element* parentElement = element->parentElement()) {
+                bool isFirstChild = isFirstChildElement(*element);
+                if (isFirstChild)
+                    addStyleRelation(checkingContext, *element, StyleRelation::FirstChild);
+                addStyleRelation(checkingContext, *parentElement, StyleRelation::ChildrenAffectedByFirstChildRules);
+                return isFirstChild;
             }
             break;
@@ -691 +685 @@
             // first-of-type matches the first element of its type
             if (element->parentElement()) {
-                if (context.resolvingMode == Mode::ResolvingStyle)
-                    element->setStyleIsAffectedByPreviousSibling();
-
-                return isFirstOfType(*element, element->tagQName(), context.resolvingMode == Mode::ResolvingStyle);
+                addStyleRelation(checkingContext, *element, StyleRelation::AffectedByPreviousSibling);
+                return isFirstOfType(checkingContext, *element, element->tagQName());
             }
             break;
         case CSSSelector::PseudoClassLastChild:
             // last-child matches the last child that is an element
-            if (Element* parentElement = element->parentElement()) {
-                bool result = parentElement->isFinishedParsingChildren() && isLastChildElement(*element);
-                if (context.resolvingMode == Mode::ResolvingStyle) {
-                    RenderStyle* childStyle = context.elementStyle ? context.elementStyle : element->renderStyle();
-                    parentElement->setChildrenAffectedByLastChildRules();
-                    if (result && childStyle)
-                        childStyle->setLastChildState();
-                }
-                return result;
+            if (const Element* parentElement = element->parentElement()) {
+                bool isLastChild = parentElement->isFinishedParsingChildren() && isLastChildElement(*element);
+                if (isLastChild)
+                    addStyleRelation(checkingContext, *element, StyleRelation::LastChild);
+                addStyleRelation(checkingContext, *parentElement, StyleRelation::ChildrenAffectedByLastChildRules);
+                return isLastChild;
             }
             break;
@@ -713 +702 @@
             // last-of-type matches the last element of its type
             if (Element* parentElement = element->parentElement()) {
-                if (context.resolvingMode == Mode::ResolvingStyle)
-                    parentElement->setChildrenAffectedByBackwardPositionalRules();
+                addStyleRelation(checkingContext, *parentElement, StyleRelation::ChildrenAffectedByBackwardPositionalRules);
                 if (!parentElement->isFinishedParsingChildren())
                     return false;
@@ -724 +712 @@
                 bool firstChild = isFirstChildElement(*element);
                 bool onlyChild = firstChild && parentElement->isFinishedParsingChildren() && isLastChildElement(*element);
-                if (context.resolvingMode == Mode::ResolvingStyle) {
-                    RenderStyle* childStyle = context.elementStyle ? context.elementStyle : element->renderStyle();
-                    parentElement->setChildrenAffectedByFirstChildRules();
-                    parentElement->setChildrenAffectedByLastChildRules();
-                    if (firstChild && childStyle)
-                        childStyle->setFirstChildState();
-                    if (onlyChild && childStyle)
-                        childStyle->setLastChildState();
-                }
+                addStyleRelation(checkingContext, *parentElement, StyleRelation::ChildrenAffectedByFirstChildRules);
+                addStyleRelation(checkingContext, *parentElement, StyleRelation::ChildrenAffectedByLastChildRules);
+                if (firstChild)
+                    addStyleRelation(checkingContext, *element, StyleRelation::FirstChild);
+                if (onlyChild)
+                    addStyleRelation(checkingContext, *element, StyleRelation::LastChild);
                 return onlyChild;
             }
@@ -739 +724 @@
             // FIXME: This selector is very slow.
             if (Element* parentElement = element->parentElement()) {
-                if (context.resolvingMode == Mode::ResolvingStyle) {
-                    element->setStyleIsAffectedByPreviousSibling();
-                    parentElement->setChildrenAffectedByBackwardPositionalRules();
-                }
+                addStyleRelation(checkingContext, *element, StyleRelation::AffectedByPreviousSibling);
+                addStyleRelation(checkingContext, *parentElement, StyleRelation::ChildrenAffectedByBackwardPositionalRules);
                 if (!parentElement->isFinishedParsingChildren())
                     return false;
-                return isFirstOfType(*element, element->tagQName(), context.resolvingMode == Mode::ResolvingStyle) && isLastOfType(*element, element->tagQName());
+                return isFirstOfType(checkingContext, *element, element->tagQName()) && isLastOfType(*element, element->tagQName());
             }
             break;
@@ -755 +738 @@
                 MatchType localMatchType = MatchType::VirtualPseudoElementOnly;
                 for (const CSSSelector* subselector = selector->selectorList()->first(); subselector; subselector = CSSSelectorList::next(subselector)) {
-                    CheckingContextWithStatus subcontext(context);
+                    LocalContext subcontext(context);
                     subcontext.inFunctionalPseudoClass = true;
                     subcontext.pseudoElementEffective = context.pseudoElementEffective;
@@ -762 +745 @@
                     PseudoIdSet localDynamicPseudoIdSet;
                     unsigned localSpecificity = 0;
-                    MatchResult result = matchRecursively(subcontext, localDynamicPseudoIdSet, localSpecificity);
+                    MatchResult result = matchRecursively(checkingContext, subcontext, localDynamicPseudoIdSet, localSpecificity);
                     if (result.match == Match::SelectorMatches) {
                         maxSpecificity = std::max(maxSpecificity, localSpecificity);
@@ -781 +764 @@
         case CSSSelector::PseudoClassPlaceholderShown:
             if (is<HTMLTextFormControlElement>(*element)) {
-                if (context.resolvingMode == Mode::ResolvingStyle) {
-                    if (RenderStyle* style = context.elementStyle ? context.elementStyle : element->renderStyle())
-                        style->setUnique();
-                }
+                addStyleRelation(checkingContext, *element, StyleRelation::Unique);
                 return downcast<HTMLTextFormControlElement>(*element).isPlaceholderVisible();
             }
@@ -794 +774 @@
                 if (const CSSSelectorList* selectorList = selector->selectorList()) {
                     unsigned selectorListSpecificity;
-                    if (matchSelectorList(context, *element, *selectorList, selectorListSpecificity))
+                    if (matchSelectorList(checkingContext, context, *element, *selectorList, selectorListSpecificity))
                         specificity = CSSSelector::addSpecificities(specificity, selectorListSpecificity);
                     else
@@ -800 +780 @@
                 }
 
-                if (context.resolvingMode == Mode::ResolvingStyle)
-                    element->setStyleIsAffectedByPreviousSibling();
+                addStyleRelation(checkingContext, *element, StyleRelation::AffectedByPreviousSibling);
 
                 int count = 1;
                 if (const CSSSelectorList* selectorList = selector->selectorList()) {
                     for (Element* sibling = ElementTraversal::previousSibling(*element); sibling; sibling = ElementTraversal::previousSibling(*sibling)) {
-                        if (context.resolvingMode == Mode::ResolvingStyle)
-                            sibling->setAffectsNextSiblingElementStyle();
+                        addStyleRelation(checkingContext, *sibling, StyleRelation::AffectsNextSibling);
 
                         unsigned ignoredSpecificity;
-                        if (matchSelectorList(context, *sibling, *selectorList, ignoredSpecificity))
+                        if (matchSelectorList(checkingContext, context, *sibling, *selectorList, ignoredSpecificity))
                             ++count;
                     }
                 } else {
-                    count += countElementsBefore(*element, context.resolvingMode == Mode::ResolvingStyle);
-                    if (context.resolvingMode == Mode::ResolvingStyle)
-                        element->setChildIndex(count);
+                    count += countElementsBefore(checkingContext, *element);
+                    addStyleRelation(checkingContext, *element, StyleRelation::NthChildIndex, count);
                 }
 
@@ -828 +805 @@
 
             if (element->parentElement()) {
-                if (context.resolvingMode == Mode::ResolvingStyle)
-                    element->setStyleIsAffectedByPreviousSibling();
-
-                int count = 1 + countElementsOfTypeBefore(*element, element->tagQName(), context.resolvingMode == Mode::ResolvingStyle);
+                addStyleRelation(checkingContext, *element, StyleRelation::AffectedByPreviousSibling);
+
+                int count = 1 + countElementsOfTypeBefore(checkingContext, *element, element->tagQName());
                 if (selector->matchNth(count))
                     return true;
@@ -842 +818 @@
                 if (const CSSSelectorList* selectorList = selector->selectorList()) {
                     unsigned selectorListSpecificity;
-                    if (matchSelectorList(context, *element, *selectorList, selectorListSpecificity))
+                    if (matchSelectorList(checkingContext, context, *element, *selectorList, selectorListSpecificity))
                         specificity = CSSSelector::addSpecificities(specificity, selectorListSpecificity);
                     else
                         return false;
 
-                    if (context.resolvingMode == Mode::ResolvingStyle) {
-                        parentElement->setChildrenAffectedByPropertyBasedBackwardPositionalRules();
-                        parentElement->setChildrenAffectedByBackwardPositionalRules();
-                    }
-                } else if (context.resolvingMode == Mode::ResolvingStyle)
-                    parentElement->setChildrenAffectedByBackwardPositionalRules();
+                    addStyleRelation(checkingContext, *parentElement, StyleRelation::ChildrenAffectedByPropertyBasedBackwardPositionalRules);
+                } else
+                    addStyleRelation(checkingContext, *parentElement, StyleRelation::ChildrenAffectedByBackwardPositionalRules);
 
                 if (!parentElement->isFinishedParsingChildren())
@@ -861 +834 @@
                     for (Element* sibling = ElementTraversal::nextSibling(*element); sibling; sibling = ElementTraversal::nextSibling(*sibling)) {
                         unsigned ignoredSpecificity;
-                        if (matchSelectorList(context, *sibling, *selectorList, ignoredSpecificity))
+                        if (matchSelectorList(checkingContext, context, *sibling, *selectorList, ignoredSpecificity))
                             ++count;
                     }
@@ -875 +848 @@
                 break;
             if (Element* parentElement = element->parentElement()) {
-                if (context.resolvingMode == Mode::ResolvingStyle)
-                    parentElement->setChildrenAffectedByBackwardPositionalRules();
+                addStyleRelation(checkingContext, *parentElement, StyleRelation::ChildrenAffectedByBackwardPositionalRules);
+
                 if (!parentElement->isFinishedParsingChildren())
                     return false;
@@ -891 +864 @@
         case CSSSelector::PseudoClassAny:
             {
-                CheckingContextWithStatus subContext(context);
-                subContext.inFunctionalPseudoClass = true;
-                subContext.pseudoElementEffective = false;
-                for (subContext.selector = selector->selectorList()->first(); subContext.selector; subContext.selector = CSSSelectorList::next(subContext.selector)) {
-                    subContext.firstSelectorOfTheFragment = subContext.selector;
+                LocalContext subcontext(context);
+                subcontext.inFunctionalPseudoClass = true;
+                subcontext.pseudoElementEffective = false;
+                for (subcontext.selector = selector->selectorList()->first(); subcontext.selector; subcontext.selector = CSSSelectorList::next(subcontext.selector)) {
+                    subcontext.firstSelectorOfTheFragment = subcontext.selector;
                     PseudoIdSet ignoreDynamicPseudo;
                     unsigned ingoredSpecificity = 0;
-                    if (matchRecursively(subContext, ignoreDynamicPseudo, ingoredSpecificity).match == Match::SelectorMatches)
+                    if (matchRecursively(checkingContext, subcontext, ignoreDynamicPseudo, ingoredSpecificity).match == Match::SelectorMatches)
                         return true;
                 }
@@ -917 +890 @@
             return element->isLink() && context.visitedMatchType == VisitedMatchType::Enabled;
         case CSSSelector::PseudoClassDrag:
-            if (context.resolvingMode == Mode::ResolvingStyle) {
-                if (context.elementStyle)
-                    context.elementStyle->setAffectedByDrag();
-                else
-                    element->setChildrenAffectedByDrag();
-            }
+            addStyleRelation(checkingContext, *element, StyleRelation::AffectedByDrag);
+
             if (element->renderer() && element->renderer()->isDragging())
                 return true;
@@ -930 +899 @@
         case CSSSelector::PseudoClassHover:
             if (m_strictParsing || element->isLink() || canMatchHoverOrActiveInQuirksMode(context)) {
-                if (context.resolvingMode == Mode::ResolvingStyle) {
-                    if (context.elementStyle)
-                        context.elementStyle->setAffectedByHover();
-                    else
-                        element->setChildrenAffectedByHover();
-                }
-                if (element->hovered() || InspectorInstrumentation::forcePseudoState(*element, CSSSelector::PseudoClassHover))
+                addStyleRelation(checkingContext, *element, StyleRelation::AffectedByHover);
+
+                if (element->hovered() || InspectorInstrumentation::forcePseudoState(const_cast<Element&>(*element), CSSSelector::PseudoClassHover))
                     return true;
             }
@@ -942 +907 @@
         case CSSSelector::PseudoClassActive:
             if (m_strictParsing || element->isLink() || canMatchHoverOrActiveInQuirksMode(context)) {
-                if (context.resolvingMode == Mode::ResolvingStyle) {
-                    if (context.elementStyle)
-                        context.elementStyle->setAffectedByActive();
-                    else
-                        element->setChildrenAffectedByActive();
-                }
-                if (element->active() || InspectorInstrumentation::forcePseudoState(*element, CSSSelector::PseudoClassActive))
+                addStyleRelation(checkingContext, *element, StyleRelation::AffectedByActive);
+
+                if (element->active() || InspectorInstrumentation::forcePseudoState(const_cast<Element&>(*element), CSSSelector::PseudoClassActive))
                     return true;
             }
@@ -1008 +969 @@
         case CSSSelector::PseudoClassScope:
             {
-                const Node* contextualReferenceNode = !context.scope ? element->document().documentElement() : context.scope;
+                const Node* contextualReferenceNode = !checkingContext.scope ? element->document().documentElement() : checkingContext.scope;
                 if (element == contextualReferenceNode)
                     return true;
@@ -1051 +1012 @@
 #if ENABLE(VIDEO_TRACK)
     if (selector->match() == CSSSelector::PseudoElement && selector->pseudoElementType() == CSSSelector::PseudoElementCue) {
-        CheckingContextWithStatus subContext(context);
+        LocalContext subcontext(context);
 
         const CSSSelector* const & selector = context.selector;
-        for (subContext.selector = selector->selectorList()->first(); subContext.selector; subContext.selector = CSSSelectorList::next(subContext.selector)) {
-            subContext.firstSelectorOfTheFragment = subContext.selector;
-            subContext.inFunctionalPseudoClass = true;
-            subContext.pseudoElementEffective = false;
+        for (subcontext.selector = selector->selectorList()->first(); subcontext.selector; subcontext.selector = CSSSelectorList::next(subcontext.selector)) {
+            subcontext.firstSelectorOfTheFragment = subcontext.selector;
+            subcontext.inFunctionalPseudoClass = true;
+            subcontext.pseudoElementEffective = false;
             PseudoIdSet ignoredDynamicPseudo;
             unsigned ignoredSpecificity = 0;
-            if (matchRecursively(subContext, ignoredDynamicPseudo, ignoredSpecificity).match == Match::SelectorMatches)
+            if (matchRecursively(checkingContext, subcontext, ignoredDynamicPseudo, ignoredSpecificity).match == Match::SelectorMatches)
                 return true;
         }
@@ -1070 +1031 @@
 }
 
-bool SelectorChecker::matchSelectorList(const CheckingContextWithStatus& baseContext, Element& element, const CSSSelectorList& selectorList, unsigned& specificity) const
+bool SelectorChecker::matchSelectorList(CheckingContext& checkingContext, const LocalContext& context, const Element& element, const CSSSelectorList& selectorList, unsigned& specificity) const
 {
     specificity = 0;
@@ -1076 +1037 @@
 
     for (const CSSSelector* subselector = selectorList.first(); subselector; subselector = CSSSelectorList::next(subselector)) {
-        CheckingContextWithStatus subcontext(baseContext);
+        LocalContext subcontext(context);
         subcontext.element = &element;
         subcontext.selector = subselector;
@@ -1084 +1045 @@
         PseudoIdSet ignoreDynamicPseudo;
         unsigned localSpecificity = 0;
-        if (matchRecursively(subcontext, ignoreDynamicPseudo, localSpecificity).match == Match::SelectorMatches) {
+        if (matchRecursively(checkingContext, subcontext, ignoreDynamicPseudo, localSpecificity).match == Match::SelectorMatches) {
             ASSERT(!ignoreDynamicPseudo);
 
@@ -1094 +1055 @@
 }
 
-bool SelectorChecker::checkScrollbarPseudoClass(const CheckingContextWithStatus& context, const CSSSelector* selector) const
+bool SelectorChecker::checkScrollbarPseudoClass(const CheckingContext& checkingContext, const Element& element, const CSSSelector* selector) const
 {
     ASSERT(selector->match() == CSSSelector::PseudoClass);
@@ -1100 +1061 @@
     switch (selector->pseudoClassType()) {
     case CSSSelector::PseudoClassWindowInactive:
-        return isWindowInactive(context.element);
+        return isWindowInactive(&element);
     case CSSSelector::PseudoClassEnabled:
-        return scrollbarMatchesEnabledPseudoClass(context);
+        return scrollbarMatchesEnabledPseudoClass(checkingContext);
     case CSSSelector::PseudoClassDisabled:
-        return scrollbarMatchesDisabledPseudoClass(context);
+        return scrollbarMatchesDisabledPseudoClass(checkingContext);
     case CSSSelector::PseudoClassHover:
-        return scrollbarMatchesHoverPseudoClass(context);
+        return scrollbarMatchesHoverPseudoClass(checkingContext);
     case CSSSelector::PseudoClassActive:
-        return scrollbarMatchesActivePseudoClass(context);
+        return scrollbarMatchesActivePseudoClass(checkingContext);
     case CSSSelector::PseudoClassHorizontal:
-        return scrollbarMatchesHorizontalPseudoClass(context);
+        return scrollbarMatchesHorizontalPseudoClass(checkingContext);
     case CSSSelector::PseudoClassVertical:
-        return scrollbarMatchesVerticalPseudoClass(context);
+        return scrollbarMatchesVerticalPseudoClass(checkingContext);
     case CSSSelector::PseudoClassDecrement:
-        return scrollbarMatchesDecrementPseudoClass(context);
+        return scrollbarMatchesDecrementPseudoClass(checkingContext);
     case CSSSelector::PseudoClassIncrement:
-        return scrollbarMatchesIncrementPseudoClass(context);
+        return scrollbarMatchesIncrementPseudoClass(checkingContext);
     case CSSSelector::PseudoClassStart:
-        return scrollbarMatchesStartPseudoClass(context);
+        return scrollbarMatchesStartPseudoClass(checkingContext);
     case CSSSelector::PseudoClassEnd:
-        return scrollbarMatchesEndPseudoClass(context);
+        return scrollbarMatchesEndPseudoClass(checkingContext);
     case CSSSelector::PseudoClassDoubleButton:
-        return scrollbarMatchesDoubleButtonPseudoClass(context);
+        return scrollbarMatchesDoubleButtonPseudoClass(checkingContext);
     case CSSSelector::PseudoClassSingleButton:
-        return scrollbarMatchesSingleButtonPseudoClass(context);
+        return scrollbarMatchesSingleButtonPseudoClass(checkingContext);
     case CSSSelector::PseudoClassNoButton:
-        return scrollbarMatchesNoButtonPseudoClass(context);
+        return scrollbarMatchesNoButtonPseudoClass(checkingContext);
     case CSSSelector::PseudoClassCornerPresent:
-        return scrollbarMatchesCornerPresentPseudoClass(context);
+        return scrollbarMatchesCornerPresentPseudoClass(checkingContext);
     default:
         return false;

trunk/Source/WebCore/css/SelectorChecker.h

@@ -3 +3 @@
  *           (C) 2004-2005 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2006, 2007 Nicholas Shanks (webkit@nickshanks.com)
- * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014 Apple Inc. All rights reserved.
+ * Copyright (C) 2005-2016 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
  * Copyright (C) 2007, 2008 Eric Seidel <eric@webkit.org>
@@ -77 +77 @@
     SelectorChecker(Document&);
 
+    struct StyleRelation {
+        enum Type {
+            AffectedByActive,
+            AffectedByDrag,
+            AffectedByEmpty,
+            AffectedByHover,
+            AffectedByPreviousSibling,
+            AffectsNextSibling,
+            ChildrenAffectedByBackwardPositionalRules,
+            ChildrenAffectedByFirstChildRules,
+            ChildrenAffectedByPropertyBasedBackwardPositionalRules,
+            ChildrenAffectedByLastChildRules,
+            FirstChild,
+            LastChild,
+            NthChildIndex,
+            Unique,
+        };
+        Element& element;
+        Type type;
+        unsigned value;
+    };
+    using StyleRelations = Vector<StyleRelation, 8>;
+
     struct CheckingContext {
         CheckingContext(SelectorChecker::Mode resolvingMode)
             : resolvingMode(resolvingMode)
-            , elementStyle(nullptr)
-            , pseudoId(NOPSEUDO)
-            , scrollbar(nullptr)
-            , scrollbarPart(NoPart)
-            , scope(nullptr)
         { }
 
-        SelectorChecker::Mode resolvingMode;
-        RenderStyle* elementStyle;
-        PseudoId pseudoId;
-        RenderScrollbar* scrollbar;
-        ScrollbarPart scrollbarPart;
-        const ContainerNode* scope;
+        const SelectorChecker::Mode resolvingMode;
+        PseudoId pseudoId { NOPSEUDO };
+        RenderScrollbar* scrollbar { nullptr };
+        ScrollbarPart scrollbarPart { NoPart };
+        const ContainerNode* scope { nullptr };
+
+        // FIXME: It would be nicer to have a separate object for return values. This requires some more work in the selector compiler.
+        StyleRelations styleRelations;
+        PseudoIdSet pseudoIDSet;
     };
 
-    struct CheckingContextWithStatus;
-
-    bool match(const CSSSelector*, Element*, const CheckingContext&, unsigned& specificity) const;
+    bool match(const CSSSelector&, const Element&, CheckingContext&, unsigned& specificity) const;
 
     static bool isCommonPseudoClassSelector(const CSSSelector*);
@@ -106 +125 @@
     static unsigned determineLinkMatchType(const CSSSelector*);
 
+    struct LocalContext;
+    
 private:
-    MatchResult matchRecursively(const CheckingContextWithStatus&, PseudoIdSet&, unsigned& specificity) const;
-    bool checkOne(const CheckingContextWithStatus&, PseudoIdSet&, MatchType&, unsigned& specificity) const;
-    bool matchSelectorList(const CheckingContextWithStatus&, Element&, const CSSSelectorList&, unsigned& specificity) const;
+    MatchResult matchRecursively(CheckingContext&, const LocalContext&, PseudoIdSet&, unsigned& specificity) const;
+    bool checkOne(CheckingContext&, const LocalContext&, PseudoIdSet&, MatchType&, unsigned& specificity) const;
+    bool matchSelectorList(CheckingContext&, const LocalContext&, const Element&, const CSSSelectorList&, unsigned& specificity) const;
 
-    bool checkScrollbarPseudoClass(const CheckingContextWithStatus&, const CSSSelector*) const;
+    bool checkScrollbarPseudoClass(const CheckingContext&, const Element&, const CSSSelector*) const;
 
     bool m_strictParsing;

trunk/Source/WebCore/css/SelectorCheckerTestFunctions.h

@@ -64 +64 @@
 }
 
-ALWAYS_INLINE bool isMediaDocument(Element* element)
+ALWAYS_INLINE bool isMediaDocument(const Element* element)
 {
     return element->document().isMediaDocument();
 }
 
-ALWAYS_INLINE bool isChecked(Element& element)
+ALWAYS_INLINE bool isChecked(const Element& element)
 {
     // Even though WinIE allows checked and indeterminate to co-exist, the CSS selector spec says that
@@ -79 +79 @@
     }
     if (is<HTMLOptionElement>(element))
-        return downcast<HTMLOptionElement>(element).selected();
-
-    return false;
-}
-
-ALWAYS_INLINE bool isInRange(Element* element)
+        return const_cast<HTMLOptionElement&>(downcast<HTMLOptionElement>(element)).selected();
+
+    return false;
+}
+
+ALWAYS_INLINE bool isInRange(const Element* element)
 {
     return element->isInRange();
 }
 
-ALWAYS_INLINE bool isOutOfRange(Element* element)
+ALWAYS_INLINE bool isOutOfRange(const Element* element)
 {
     return element->isOutOfRange();

trunk/Source/WebCore/css/StyleResolver.h

@@ -611 +611 @@
         SelectorChecker::CheckingContext selectorCheckingContext(SelectorChecker::Mode::QueryingRules);
         unsigned ignoredSpecificity;
-        if (selectorChecker.match(s, regionElement, selectorCheckingContext, ignoredSpecificity))
+        if (selectorChecker.match(*s, *regionElement, selectorCheckingContext, ignoredSpecificity))
             return true;
     }

trunk/Source/WebCore/cssjit/SelectorCompiler.cpp

@@ -1 +1 @@
 /*
- * Copyright (C) 2013-2015 Apple Inc. All rights reserved.
+ * Copyright (C) 2013-2016 Apple Inc. All rights reserved.
  * Copyright (C) 2014 Yusuke Suzuki <utatane.tea@gmail.com>
  *
@@ -292 +292 @@
     void generateContextFunctionCallTest(Assembler::JumpList& failureCases, JSC::FunctionPtr);
     void generateElementIsActive(Assembler::JumpList& failureCases, const SelectorFragment&);
-    void generateElementIsEmpty(Assembler::JumpList& failureCases, const SelectorFragment&);
-    void generateElementIsFirstChild(Assembler::JumpList& failureCases, const SelectorFragment&);
+    void generateElementIsEmpty(Assembler::JumpList& failureCases);
+    void generateElementIsFirstChild(Assembler::JumpList& failureCases);
     void generateElementIsHovered(Assembler::JumpList& failureCases, const SelectorFragment&);
     void generateElementIsInLanguage(Assembler::JumpList& failureCases, const SelectorFragment&);
     void generateElementIsInLanguage(Assembler::JumpList& failureCases, const Vector<AtomicString>*);
-    void generateElementIsLastChild(Assembler::JumpList& failureCases, const SelectorFragment&);
-    void generateElementIsOnlyChild(Assembler::JumpList& failureCases, const SelectorFragment&);
-    void generateElementHasPlaceholderShown(Assembler::JumpList& failureCases, const SelectorFragment&);
+    void generateElementIsLastChild(Assembler::JumpList& failureCases);
+    void generateElementIsOnlyChild(Assembler::JumpList& failureCases);
+    void generateElementHasPlaceholderShown(Assembler::JumpList& failureCases);
     void generateSynchronizeStyleAttribute(Assembler::RegisterID elementDataArraySizeAndFlags);
     void generateSynchronizeAllAnimatedSVGAttribute(Assembler::RegisterID elementDataArraySizeAndFlags);
@@ -324 +324 @@
 
     // Helpers.
-    void addFlagsToElementStyleFromContext(Assembler::RegisterID checkingContext, int64_t);
+    void generateAddStyleRelationIfResolvingStyle(Assembler::RegisterID element, SelectorChecker::StyleRelation::Type, Optional<Assembler::RegisterID> value = { });
+    void generateAddStyleRelation(Assembler::RegisterID checkingContext, Assembler::RegisterID element, SelectorChecker::StyleRelation::Type, Optional<Assembler::RegisterID> value = { });
     Assembler::Jump branchOnResolvingModeWithCheckingContext(Assembler::RelationalCondition, SelectorChecker::Mode, Assembler::RegisterID checkingContext);
     Assembler::Jump branchOnResolvingMode(Assembler::RelationalCondition, SelectorChecker::Mode, Assembler::RegisterID checkingContext);
@@ -333 +334 @@
     void generateRequestedPseudoElementEqualsToSelectorPseudoElement(Assembler::JumpList& failureCases, const SelectorFragment&, Assembler::RegisterID checkingContext);
     void generateSpecialFailureInQuirksModeForActiveAndHoverIfNeeded(Assembler::JumpList& failureCases, const SelectorFragment&);
-    void markElementIfResolvingStyle(Assembler::RegisterID, int32_t);
     Assembler::JumpList jumpIfNoPreviousAdjacentElement();
     Assembler::JumpList jumpIfNoNextAdjacentElement();
@@ -1892 +1892 @@
         }
         if (shouldMarkStyleIsAffectedByPreviousSibling(fragment))
-            markElementIfResolvingStyle(elementAddressRegister, Node::flagStyleIsAffectedByPreviousSibling());
+            generateAddStyleRelationIfResolvingStyle(elementAddressRegister, SelectorChecker::StyleRelation::AffectedByPreviousSibling);
         generateBacktrackingTailsIfNeeded(failureCases, fragment);
     }
@@ -2136 +2136 @@
 {
     generateWalkToPreviousAdjacent(failureCases, fragment);
-    markElementIfResolvingStyle(elementAddressRegister, Node::flagAffectsNextSiblingElementStyle());
+    generateAddStyleRelationIfResolvingStyle(elementAddressRegister, SelectorChecker::StyleRelation::AffectsNextSibling);
 
     Assembler::JumpList matchingTagNameFailureCases;
@@ -2161 +2161 @@
 
     generateWalkToPreviousAdjacent(failureCases, fragment);
-    markElementIfResolvingStyle(elementAddressRegister, Node::flagAffectsNextSiblingElementStyle());
+    generateAddStyleRelationIfResolvingStyle(elementAddressRegister, SelectorChecker::StyleRelation::AffectsNextSibling);
 
     if (fragment.backtrackingFlags & BacktrackingFlag::IndirectAdjacentEntryPoint)
@@ -2171 +2171 @@
 }
 
-
-void SelectorCodeGenerator::addFlagsToElementStyleFromContext(Assembler::RegisterID checkingContext, int64_t newFlag)
+void SelectorCodeGenerator::generateAddStyleRelationIfResolvingStyle(Assembler::RegisterID element, SelectorChecker::StyleRelation::Type relationType, Optional<Assembler::RegisterID> value)
+{
+    if (m_selectorContext == SelectorContext::QuerySelector)
+        return;
+
+    LocalRegister checkingContext(m_registerAllocator);
+    Assembler::Jump notResolvingStyle = jumpIfNotResolvingStyle(checkingContext);
+
+    generateAddStyleRelation(checkingContext, element, relationType, value);
+
+    notResolvingStyle.link(&m_assembler);
+}
+
+static void addStyleRelationFunction(SelectorChecker::CheckingContext* checkingContext, Element* element)
+{
+    checkingContext->styleRelations.append({ *element, SelectorChecker::StyleRelation::AffectedByActive, 1 });
+}
+
+void SelectorCodeGenerator::generateAddStyleRelation(Assembler::RegisterID checkingContext, Assembler::RegisterID element, SelectorChecker::StyleRelation::Type relationType, Optional<Assembler::RegisterID> value)
 {
     ASSERT(m_selectorContext != SelectorContext::QuerySelector);
 
-    LocalRegister childStyle(m_registerAllocator);
-    m_assembler.loadPtr(Assembler::Address(checkingContext, OBJECT_OFFSETOF(SelectorChecker::CheckingContext, elementStyle)), childStyle);
-
-    // FIXME: We should look into doing something smart in MacroAssembler instead.
-    Assembler::Address flagAddress(childStyle, RenderStyle::noninheritedFlagsMemoryOffset() + RenderStyle::NonInheritedFlags::flagsMemoryOffset());
-#if CPU(ARM_THUMB2)
-    int32_t flagLowBits = newFlag & 0xffffffff;
-    int32_t flagHighBits = newFlag >> 32;
-    if (flagLowBits)
-        m_assembler.or32(Assembler::TrustedImm32(flagLowBits), flagAddress);
-    if (flagHighBits) {
-        Assembler::Address flagHighAddress = flagAddress.withOffset(4);
-        m_assembler.or32(Assembler::TrustedImm32(flagHighBits), flagHighAddress);
-    }
-#elif CPU(X86_64) || CPU(ARM64)
-    LocalRegister flags(m_registerAllocator);
-    m_assembler.load64(flagAddress, flags);
-    LocalRegister isFirstChildStateFlagImmediate(m_registerAllocator);
-    m_assembler.move(Assembler::TrustedImm64(newFlag), isFirstChildStateFlagImmediate);
-    m_assembler.or64(isFirstChildStateFlagImmediate, flags);
-    m_assembler.store64(flags, flagAddress);
-#else
-#error SelectorCodeGenerator::addFlagsToElementStyleFromContext not implemented for this architecture.
-#endif
+    // FIXME: Append to vector without a function call at least when there is sufficient capacity.
+    FunctionCall functionCall(m_assembler, m_registerAllocator, m_stackAllocator, m_functionCalls);
+    functionCall.setFunctionAddress(addStyleRelationFunction);
+    functionCall.setTwoArguments(checkingContext, element);
+    functionCall.call();
+
+    Assembler::Address vectorAddress(checkingContext, OBJECT_OFFSETOF(SelectorChecker::CheckingContext, styleRelations));
+    auto dataAddress = vectorAddress.withOffset(SelectorChecker::StyleRelations::dataMemoryOffset());
+    auto sizeAddress = vectorAddress.withOffset(SelectorChecker::StyleRelations::sizeMemoryOffset());
+
+    LocalRegister relationPointer(m_registerAllocator);
+    m_assembler.load32(sizeAddress, relationPointer);
+    m_assembler.sub32(Assembler::TrustedImm32(1), relationPointer);
+    m_assembler.mul32(Assembler::TrustedImm32(sizeof(SelectorChecker::StyleRelation)), relationPointer, relationPointer);
+    m_assembler.addPtr(dataAddress, relationPointer);
+
+    Assembler::Address typeAddress(relationPointer, OBJECT_OFFSETOF(SelectorChecker::StyleRelation, type));
+    m_assembler.store32(Assembler::TrustedImm32(relationType), typeAddress);
+
+    if (value) {
+        Assembler::Address valueAddress(relationPointer, OBJECT_OFFSETOF(SelectorChecker::StyleRelation, value));
+        m_assembler.store32(*value, valueAddress);
+    }
 }
 
@@ -2419 +2435 @@
 
     failureCases.append(modulo(Assembler::NonZero, inputDividend, divisor));
-}
-
-static void setNodeFlag(Assembler& assembler, Assembler::RegisterID elementAddress, int32_t flag)
-{
-    assembler.or32(Assembler::TrustedImm32(flag), Assembler::Address(elementAddress, Node::nodeFlagsMemoryOffset()));
-}
-
-void SelectorCodeGenerator::markElementIfResolvingStyle(Assembler::RegisterID element, int32_t nodeFlag)
-{
-    if (m_selectorContext == SelectorContext::QuerySelector)
-        return;
-
-    Assembler::JumpList skipMarking;
-    {
-        LocalRegister checkingContext(m_registerAllocator);
-        skipMarking.append(jumpIfNotResolvingStyle(checkingContext));
-    }
-
-    setNodeFlag(m_assembler, element, nodeFlag);
-
-    skipMarking.link(&m_assembler);
 }
 
@@ -2548 +2543 @@
         generateElementIsActive(matchingPostTagNameFailureCases, fragment);
     if (fragment.pseudoClasses.contains(CSSSelector::PseudoClassEmpty))
-        generateElementIsEmpty(matchingPostTagNameFailureCases, fragment);
+        generateElementIsEmpty(matchingPostTagNameFailureCases);
     if (fragment.pseudoClasses.contains(CSSSelector::PseudoClassHover))
         generateElementIsHovered(matchingPostTagNameFailureCases, fragment);
     if (fragment.pseudoClasses.contains(CSSSelector::PseudoClassOnlyChild))
-        generateElementIsOnlyChild(matchingPostTagNameFailureCases, fragment);
+        generateElementIsOnlyChild(matchingPostTagNameFailureCases);
     if (fragment.pseudoClasses.contains(CSSSelector::PseudoClassPlaceholderShown))
-        generateElementHasPlaceholderShown(matchingPostTagNameFailureCases, fragment);
+        generateElementHasPlaceholderShown(matchingPostTagNameFailureCases);
     if (fragment.pseudoClasses.contains(CSSSelector::PseudoClassFirstChild))
-        generateElementIsFirstChild(matchingPostTagNameFailureCases, fragment);
+        generateElementIsFirstChild(matchingPostTagNameFailureCases);
     if (fragment.pseudoClasses.contains(CSSSelector::PseudoClassLastChild))
-        generateElementIsLastChild(matchingPostTagNameFailureCases, fragment);
+        generateElementIsLastChild(matchingPostTagNameFailureCases);
     if (!fragment.nthChildFilters.isEmpty())
         generateElementIsNthChild(matchingPostTagNameFailureCases, fragment);
@@ -3053 +3048 @@
 }
 
-static void setFirstChildState(Element* element)
-{
-    if (RenderStyle* style = element->renderStyle())
-        style->setFirstChildState();
-}
-
 static bool elementIsActive(Element* element)
 {
@@ -3064 +3053 @@
 }
 
-static bool elementIsActiveForStyleResolution(Element* element, const SelectorChecker::CheckingContext* checkingContext)
-{
-    if (checkingContext->resolvingMode == SelectorChecker::Mode::ResolvingStyle)
-        element->setChildrenAffectedByActive();
-    return element->active() || InspectorInstrumentation::forcePseudoState(*element, CSSSelector::PseudoClassActive);
-}
-
 void SelectorCodeGenerator::generateElementIsActive(Assembler::JumpList& failureCases, const SelectorFragment& fragment)
 {
     generateSpecialFailureInQuirksModeForActiveAndHoverIfNeeded(failureCases, fragment);
-    if (m_selectorContext == SelectorContext::QuerySelector) {
-        FunctionCall functionCall(m_assembler, m_registerAllocator, m_stackAllocator, m_functionCalls);
-        functionCall.setFunctionAddress(elementIsActive);
-        functionCall.setOneArgument(elementAddressRegister);
-        failureCases.append(functionCall.callAndBranchOnBooleanReturnValue(Assembler::Zero));
-        return;
-    }
-
-    if (fragmentMatchesTheRightmostElement(m_selectorContext, fragment)) {
-        LocalRegister checkingContext(m_registerAllocator);
-        Assembler::Jump notResolvingStyle = jumpIfNotResolvingStyle(checkingContext);
-        addFlagsToElementStyleFromContext(checkingContext, RenderStyle::NonInheritedFlags::flagIsaffectedByActive());
-        notResolvingStyle.link(&m_assembler);
-
-        FunctionCall functionCall(m_assembler, m_registerAllocator, m_stackAllocator, m_functionCalls);
-        functionCall.setFunctionAddress(elementIsActive);
-        functionCall.setOneArgument(elementAddressRegister);
-        failureCases.append(functionCall.callAndBranchOnBooleanReturnValue(Assembler::Zero));
-    } else {
-        Assembler::RegisterID checkingContext = m_registerAllocator.allocateRegisterWithPreference(JSC::GPRInfo::argumentGPR1);
-        loadCheckingContext(checkingContext);
-        m_registerAllocator.deallocateRegister(checkingContext);
-
-        FunctionCall functionCall(m_assembler, m_registerAllocator, m_stackAllocator, m_functionCalls);
-        functionCall.setFunctionAddress(elementIsActiveForStyleResolution);
-        functionCall.setTwoArguments(elementAddressRegister, checkingContext);
-        failureCases.append(functionCall.callAndBranchOnBooleanReturnValue(Assembler::Zero));
-    }
+
+    generateAddStyleRelationIfResolvingStyle(elementAddressRegister, SelectorChecker::StyleRelation::AffectedByActive);
+
+    FunctionCall functionCall(m_assembler, m_registerAllocator, m_stackAllocator, m_functionCalls);
+    functionCall.setFunctionAddress(elementIsActive);
+    functionCall.setOneArgument(elementAddressRegister);
+    failureCases.append(functionCall.callAndBranchOnBooleanReturnValue(Assembler::Zero));
 }
 
@@ -3130 +3091 @@
 }
 
-static void setElementStyleIsAffectedByEmpty(Element* element)
-{
-    element->setStyleAffectedByEmpty();
-}
-
-static void setElementStyleFromContextIsAffectedByEmptyAndUpdateRenderStyleIfNecessary(SelectorChecker::CheckingContext* context, bool isEmpty)
-{
-    ASSERT(context->elementStyle);
-    context->elementStyle->setEmptyState(isEmpty);
-}
-
-void SelectorCodeGenerator::generateElementIsEmpty(Assembler::JumpList& failureCases, const SelectorFragment& fragment)
+void SelectorCodeGenerator::generateElementIsEmpty(Assembler::JumpList& failureCases)
 {
     if (m_selectorContext == SelectorContext::QuerySelector) {
@@ -3156 +3106 @@
     notEmpty.link(&m_assembler);
 
-    Assembler::Jump skipMarking;
-    if (fragmentMatchesTheRightmostElement(m_selectorContext, fragment)) {
-        {
-            LocalRegister checkingContext(m_registerAllocator);
-            skipMarking = jumpIfNotResolvingStyle(checkingContext);
-
-            FunctionCall functionCall(m_assembler, m_registerAllocator, m_stackAllocator, m_functionCalls);
-            functionCall.setFunctionAddress(setElementStyleFromContextIsAffectedByEmptyAndUpdateRenderStyleIfNecessary);
-            functionCall.setTwoArguments(checkingContext, isEmptyResults);
-            functionCall.call();
-        }
-
-        FunctionCall functionCall(m_assembler, m_registerAllocator, m_stackAllocator, m_functionCalls);
-        functionCall.setFunctionAddress(setElementStyleIsAffectedByEmpty);
-        functionCall.setOneArgument(elementAddressRegister);
-        functionCall.call();
-    } else {
-        {
-            LocalRegister checkingContext(m_registerAllocator);
-            skipMarking = jumpIfNotResolvingStyle(checkingContext);
-        }
-        FunctionCall functionCall(m_assembler, m_registerAllocator, m_stackAllocator, m_functionCalls);
-        functionCall.setFunctionAddress(setElementStyleIsAffectedByEmpty);
-        functionCall.setOneArgument(elementAddressRegister);
-        functionCall.call();
-    }
-    skipMarking.link(&m_assembler);
+    generateAddStyleRelationIfResolvingStyle(elementAddressRegister, SelectorChecker::StyleRelation::AffectedByEmpty, Assembler::RegisterID(isEmptyResults));
 
     failureCases.append(m_assembler.branchTest32(Assembler::Zero, isEmptyResults));
 }
 
-void SelectorCodeGenerator::generateElementIsFirstChild(Assembler::JumpList& failureCases, const SelectorFragment& fragment)
+void SelectorCodeGenerator::generateElementIsFirstChild(Assembler::JumpList& failureCases)
 {
     if (m_selectorContext == SelectorContext::QuerySelector) {
@@ -3217 +3141 @@
     Assembler::Jump notResolvingStyle = jumpIfNotResolvingStyle(checkingContext);
 
-    setNodeFlag(m_assembler, parentElement, Node::flagChildrenAffectedByFirstChildRulesFlag());
+    generateAddStyleRelation(checkingContext, parentElement, SelectorChecker::StyleRelation::ChildrenAffectedByFirstChildRules);
     m_registerAllocator.deallocateRegister(parentElement);
 
@@ -3224 +3148 @@
     failureCases.append(m_assembler.branchTest32(Assembler::NonZero, isFirstChildRegister));
 
-    if (fragmentMatchesTheRightmostElement(m_selectorContext, fragment))
-        addFlagsToElementStyleFromContext(checkingContext, RenderStyle::NonInheritedFlags::setFirstChildStateFlags());
-    else {
-        FunctionCall functionCall(m_assembler, m_registerAllocator, m_stackAllocator, m_functionCalls);
-        functionCall.setFunctionAddress(setFirstChildState);
-        Assembler::RegisterID elementAddress = elementAddressRegister;
-        functionCall.setOneArgument(elementAddress);
-        functionCall.call();
-    }
+    generateAddStyleRelation(checkingContext, elementAddressRegister, SelectorChecker::StyleRelation::FirstChild);
 
     notResolvingStyle.link(&m_assembler);
@@ -3243 +3159 @@
 }
 
-static bool elementIsHoveredForStyleResolution(Element* element, const SelectorChecker::CheckingContext* checkingContext)
-{
-    if (checkingContext->resolvingMode == SelectorChecker::Mode::ResolvingStyle)
-        element->setChildrenAffectedByHover();
-    return element->hovered() || InspectorInstrumentation::forcePseudoState(*element, CSSSelector::PseudoClassHover);
-}
-
 void SelectorCodeGenerator::generateElementIsHovered(Assembler::JumpList& failureCases, const SelectorFragment& fragment)
 {
     generateSpecialFailureInQuirksModeForActiveAndHoverIfNeeded(failureCases, fragment);
-    if (m_selectorContext == SelectorContext::QuerySelector) {
-        FunctionCall functionCall(m_assembler, m_registerAllocator, m_stackAllocator, m_functionCalls);
-        functionCall.setFunctionAddress(elementIsHovered);
-        functionCall.setOneArgument(elementAddressRegister);
-        failureCases.append(functionCall.callAndBranchOnBooleanReturnValue(Assembler::Zero));
-        return;
-    }
-
-    if (fragmentMatchesTheRightmostElement(m_selectorContext, fragment)) {
-        LocalRegisterWithPreference checkingContext(m_registerAllocator, JSC::GPRInfo::argumentGPR1);
-        Assembler::Jump notResolvingStyle = jumpIfNotResolvingStyle(checkingContext);
-        addFlagsToElementStyleFromContext(checkingContext, RenderStyle::NonInheritedFlags::flagIsaffectedByHover());
-        notResolvingStyle.link(&m_assembler);
-
-        FunctionCall functionCall(m_assembler, m_registerAllocator, m_stackAllocator, m_functionCalls);
-        functionCall.setFunctionAddress(elementIsHovered);
-        functionCall.setOneArgument(elementAddressRegister);
-        failureCases.append(functionCall.callAndBranchOnBooleanReturnValue(Assembler::Zero));
-    } else {
-        Assembler::RegisterID checkingContext = m_registerAllocator.allocateRegisterWithPreference(JSC::GPRInfo::argumentGPR1);
-        loadCheckingContext(checkingContext);
-        m_registerAllocator.deallocateRegister(checkingContext);
-
-        FunctionCall functionCall(m_assembler, m_registerAllocator, m_stackAllocator, m_functionCalls);
-        functionCall.setFunctionAddress(elementIsHoveredForStyleResolution);
-        functionCall.setTwoArguments(elementAddressRegister, checkingContext);
-        failureCases.append(functionCall.callAndBranchOnBooleanReturnValue(Assembler::Zero));
-    }
+
+    generateAddStyleRelationIfResolvingStyle(elementAddressRegister, SelectorChecker::StyleRelation::AffectedByHover);
+
+    FunctionCall functionCall(m_assembler, m_registerAllocator, m_stackAllocator, m_functionCalls);
+    functionCall.setFunctionAddress(elementIsHovered);
+    functionCall.setOneArgument(elementAddressRegister);
+    failureCases.append(functionCall.callAndBranchOnBooleanReturnValue(Assembler::Zero));
 }
 
@@ -3301 +3189 @@
 }
 
-static void setLastChildState(Element* element)
-{
-    if (RenderStyle* style = element->renderStyle())
-        style->setLastChildState();
-}
-
-void SelectorCodeGenerator::generateElementIsLastChild(Assembler::JumpList& failureCases, const SelectorFragment& fragment)
+void SelectorCodeGenerator::generateElementIsLastChild(Assembler::JumpList& failureCases)
 {
     if (m_selectorContext == SelectorContext::QuerySelector) {
@@ -3343 +3225 @@
     Assembler::Jump notResolvingStyle = jumpIfNotResolvingStyle(checkingContext);
 
-    setNodeFlag(m_assembler, parentElement, Node::flagChildrenAffectedByLastChildRulesFlag());
+    generateAddStyleRelation(checkingContext, parentElement, SelectorChecker::StyleRelation::ChildrenAffectedByLastChildRules);
     m_registerAllocator.deallocateRegister(parentElement);
 
@@ -3350 +3232 @@
     failureCases.append(m_assembler.branchTest32(Assembler::NonZero, isLastChildRegister));
 
-    if (fragmentMatchesTheRightmostElement(m_selectorContext, fragment))
-        addFlagsToElementStyleFromContext(checkingContext, RenderStyle::NonInheritedFlags::setLastChildStateFlags());
-    else {
-        FunctionCall functionCall(m_assembler, m_registerAllocator, m_stackAllocator, m_functionCalls);
-        functionCall.setFunctionAddress(setLastChildState);
-        Assembler::RegisterID elementAddress = elementAddressRegister;
-        functionCall.setOneArgument(elementAddress);
-        functionCall.call();
-    }
+    generateAddStyleRelation(checkingContext, elementAddressRegister, SelectorChecker::StyleRelation::LastChild);
 
     notResolvingStyle.link(&m_assembler);
@@ -3364 +3238 @@
 }
 
-static void setOnlyChildState(Element* element)
-{
-    if (RenderStyle* style = element->renderStyle()) {
-        style->setFirstChildState();
-        style->setLastChildState();
-    }
-}
-
-void SelectorCodeGenerator::generateElementIsOnlyChild(Assembler::JumpList& failureCases, const SelectorFragment& fragment)
+void SelectorCodeGenerator::generateElementIsOnlyChild(Assembler::JumpList& failureCases)
 {
     // Is Only child is pretty much a combination of isFirstChild + isLastChild. The main difference is that tree marking is combined.
@@ -3418 +3284 @@
     Assembler::Jump notResolvingStyle = jumpIfNotResolvingStyle(checkingContext);
 
-    setNodeFlag(m_assembler, parentElement, Node::flagChildrenAffectedByFirstChildRulesFlag() | Node::flagChildrenAffectedByLastChildRulesFlag());
+    generateAddStyleRelation(checkingContext, parentElement, SelectorChecker::StyleRelation::ChildrenAffectedByFirstChildRules);
+    generateAddStyleRelation(checkingContext, parentElement, SelectorChecker::StyleRelation::ChildrenAffectedByLastChildRules);
+
     m_registerAllocator.deallocateRegister(parentElement);
 
@@ -3425 +3293 @@
     failureCases.append(m_assembler.branchTest32(Assembler::NonZero, isOnlyChildRegister));
 
-    if (fragmentMatchesTheRightmostElement(m_selectorContext, fragment))
-        addFlagsToElementStyleFromContext(checkingContext, RenderStyle::NonInheritedFlags::setFirstChildStateFlags() | RenderStyle::NonInheritedFlags::setLastChildStateFlags());
-    else {
-        FunctionCall functionCall(m_assembler, m_registerAllocator, m_stackAllocator, m_functionCalls);
-        functionCall.setFunctionAddress(setOnlyChildState);
-        Assembler::RegisterID elementAddress = elementAddressRegister;
-        functionCall.setOneArgument(elementAddress);
-        functionCall.call();
-    }
+    generateAddStyleRelation(checkingContext, elementAddressRegister, SelectorChecker::StyleRelation::FirstChild);
+    generateAddStyleRelation(checkingContext, elementAddressRegister, SelectorChecker::StyleRelation::LastChild);
 
     notResolvingStyle.link(&m_assembler);
@@ -3439 +3300 @@
 }
 
-static bool makeContextStyleUniqueIfNecessaryAndTestIsPlaceholderShown(Element* element, const SelectorChecker::CheckingContext* checkingContext)
+static bool makeContextStyleUniqueIfNecessaryAndTestIsPlaceholderShown(Element* element, SelectorChecker::CheckingContext* checkingContext)
 {
     if (is<HTMLTextFormControlElement>(*element)) {
         if (checkingContext->resolvingMode == SelectorChecker::Mode::ResolvingStyle)
-            checkingContext->elementStyle->setUnique();
+            checkingContext->styleRelations.append({ *element, SelectorChecker::StyleRelation::Unique, 1 });
         return downcast<HTMLTextFormControlElement>(*element).isPlaceholderVisible();
     }
@@ -3449 +3310 @@
 }
 
-static bool makeElementStyleUniqueIfNecessaryAndTestIsPlaceholderShown(Element* element, const SelectorChecker::CheckingContext* checkingContext)
-{
-    if (is<HTMLTextFormControlElement>(*element)) {
-        if (checkingContext->resolvingMode == SelectorChecker::Mode::ResolvingStyle) {
-            if (RenderStyle* style = element->renderStyle())
-                style->setUnique();
-        }
-        return downcast<HTMLTextFormControlElement>(*element).isPlaceholderVisible();
-    }
-    return false;
-}
-
 static bool isPlaceholderShown(Element* element)
 {
@@ -3466 +3315 @@
 }
 
-void SelectorCodeGenerator::generateElementHasPlaceholderShown(Assembler::JumpList& failureCases, const SelectorFragment& fragment)
+void SelectorCodeGenerator::generateElementHasPlaceholderShown(Assembler::JumpList& failureCases)
 {
     if (m_selectorContext == SelectorContext::QuerySelector) {
@@ -3481 +3330 @@
 
     FunctionCall functionCall(m_assembler, m_registerAllocator, m_stackAllocator, m_functionCalls);
-    if (fragmentMatchesTheRightmostElement(m_selectorContext, fragment))
-        functionCall.setFunctionAddress(makeContextStyleUniqueIfNecessaryAndTestIsPlaceholderShown);
-    else
-        functionCall.setFunctionAddress(makeElementStyleUniqueIfNecessaryAndTestIsPlaceholderShown);
+    functionCall.setFunctionAddress(makeContextStyleUniqueIfNecessaryAndTestIsPlaceholderShown);
     functionCall.setTwoArguments(elementAddressRegister, checkingContext);
     failureCases.append(functionCall.callAndBranchOnBooleanReturnValue(Assembler::Zero));
@@ -3586 +3432 @@
 }
 
-static void setElementChildIndex(Element* element, int index)
-{
-    element->setChildIndex(index);
-}
-
 static bool nthFilterIsAlwaysSatisified(int a, int b)
 {
@@ -3617 +3458 @@
 
     if (!isAdjacentRelation(fragment.relationToRightFragment))
-        markElementIfResolvingStyle(elementAddressRegister, Node::flagStyleIsAffectedByPreviousSibling());
+        generateAddStyleRelationIfResolvingStyle(elementAddressRegister, SelectorChecker::StyleRelation::AffectedByPreviousSibling);
 
     // Setup the counter at 1.
@@ -3635 +3476 @@
         Assembler::JumpList noCachedChildIndexCases;
         generateWalkToPreviousAdjacentElement(noMoreSiblingsCases, previousSibling);
-        markElementIfResolvingStyle(previousSibling, Node::flagAffectsNextSiblingElementStyle());
+        generateAddStyleRelationIfResolvingStyle(previousSibling, SelectorChecker::StyleRelation::AffectsNextSibling);
         noCachedChildIndexCases.append(m_assembler.branchTest32(Assembler::Zero, Assembler::Address(previousSibling, Node::nodeFlagsMemoryOffset()), Assembler::TrustedImm32(Node::flagHasRareData())));
         {
@@ -3651 +3492 @@
         Assembler::Label loopStart = m_assembler.label();
         generateWalkToPreviousAdjacentElement(noMoreSiblingsCases, previousSibling);
-        markElementIfResolvingStyle(previousSibling, Node::flagAffectsNextSiblingElementStyle());
+        generateAddStyleRelationIfResolvingStyle(previousSibling, SelectorChecker::StyleRelation::AffectsNextSibling);
         m_assembler.add32(Assembler::TrustedImm32(1), elementCounter);
         m_assembler.jump().linkTo(loopStart, &m_assembler);
@@ -3657 +3498 @@
     }
 
-    // Tree marking when doing style resolution.
-    if (m_selectorContext != SelectorContext::QuerySelector) {
-        LocalRegister checkingContext(m_registerAllocator);
-        Assembler::Jump notResolvingStyle = jumpIfNotResolvingStyle(checkingContext);
-
-        Assembler::RegisterID elementAddress = elementAddressRegister;
-        FunctionCall functionCall(m_assembler, m_registerAllocator, m_stackAllocator, m_functionCalls);
-        functionCall.setFunctionAddress(setElementChildIndex);
-        functionCall.setTwoArguments(elementAddress, elementCounter);
-        functionCall.call();
-
-        notResolvingStyle.link(&m_assembler);
-    }
+    generateAddStyleRelationIfResolvingStyle(elementAddressRegister, SelectorChecker::StyleRelation::NthChildIndex, Assembler::RegisterID(elementCounter));
 
     for (const auto& slot : validSubsetFilters)
@@ -3696 +3525 @@
 
     if (!isAdjacentRelation(fragment.relationToRightFragment))
-        markElementIfResolvingStyle(elementAddressRegister, Node::flagStyleIsAffectedByPreviousSibling());
+        generateAddStyleRelationIfResolvingStyle(elementAddressRegister, SelectorChecker::StyleRelation::AffectedByPreviousSibling);
 
     for (const NthChildOfSelectorInfo* nthChildOfSelectorInfo : validSubsetFilters) {
@@ -3713 +3542 @@
 
             generateWalkToPreviousAdjacentElement(noMoreSiblingsCases, previousSibling);
-            markElementIfResolvingStyle(previousSibling, Node::flagAffectsNextSiblingElementStyle());
+            generateAddStyleRelationIfResolvingStyle(previousSibling, SelectorChecker::StyleRelation::AffectsNextSibling);
 
             Assembler::JumpList localFailureCases;
@@ -3728 +3557 @@
 }
 
-static void setChildrenAffectedByBackwardPositionalRules(Element* element)
-{
-    element->setChildrenAffectedByBackwardPositionalRules();
-}
-
 void SelectorCodeGenerator::generateElementIsNthLastChild(Assembler::JumpList& failureCases, const SelectorFragment& fragment)
 {
@@ -3741 +3565 @@
         generateWalkToParentElement(failureCases, parentElement);
 
-        if (m_selectorContext != SelectorContext::QuerySelector) {
-            Assembler::Jump skipMarking;
-            {
-                LocalRegister checkingContext(m_registerAllocator);
-                skipMarking = jumpIfNotResolvingStyle(checkingContext);
-            }
-
-            FunctionCall functionCall(m_assembler, m_registerAllocator, m_stackAllocator, m_functionCalls);
-            functionCall.setFunctionAddress(setChildrenAffectedByBackwardPositionalRules);
-            functionCall.setOneArgument(parentElement);
-            functionCall.call();
-
-            skipMarking.link(&m_assembler);
-        }
+        generateAddStyleRelationIfResolvingStyle(parentElement, SelectorChecker::StyleRelation::ChildrenAffectedByBackwardPositionalRules);
 
         failureCases.append(m_assembler.branchTest32(Assembler::Zero, Assembler::Address(parentElement, Node::nodeFlagsMemoryOffset()), Assembler::TrustedImm32(Node::flagIsParsingChildrenFinished())));
@@ -3789 +3600 @@
 }
 
-static void setParentAffectedByLastChildOf(Element* parentElement)
-{
-    ASSERT(parentElement);
-    parentElement->setChildrenAffectedByPropertyBasedBackwardPositionalRules();
-    parentElement->setChildrenAffectedByBackwardPositionalRules();
-}
-
 void SelectorCodeGenerator::generateElementIsNthLastChildOf(Assembler::JumpList& failureCases, const SelectorFragment& fragment)
 {
@@ -3804 +3608 @@
         generateWalkToParentElement(failureCases, parentElement);
 
-        if (m_selectorContext != SelectorContext::QuerySelector) {
-            Assembler::Jump skipMarking;
-            {
-                LocalRegister checkingContext(m_registerAllocator);
-                skipMarking = jumpIfNotResolvingStyle(checkingContext);
-            }
-
-            FunctionCall functionCall(m_assembler, m_registerAllocator, m_stackAllocator, m_functionCalls);
-            functionCall.setFunctionAddress(setParentAffectedByLastChildOf);
-            functionCall.setOneArgument(parentElement);
-            functionCall.call();
-
-            skipMarking.link(&m_assembler);
-        }
+        generateAddStyleRelationIfResolvingStyle(parentElement, SelectorChecker::StyleRelation::ChildrenAffectedByPropertyBasedBackwardPositionalRules);
 
         failureCases.append(m_assembler.branchTest32(Assembler::Zero, Assembler::Address(parentElement, Node::nodeFlagsMemoryOffset()), Assembler::TrustedImm32(Node::flagIsParsingChildrenFinished())));
@@ -4004 +3795 @@
     if (dynamicPseudo < FIRST_INTERNAL_PSEUDOID) {
         failureCases.append(branchOnResolvingModeWithCheckingContext(Assembler::NotEqual, SelectorChecker::Mode::ResolvingStyle, checkingContext));
-        addFlagsToElementStyleFromContext(checkingContext, RenderStyle::NonInheritedFlags::flagPseudoStyle(dynamicPseudo));
+
+        Assembler::Address pseudoIDSetAddress(checkingContext, OBJECT_OFFSETOF(SelectorChecker::CheckingContext, pseudoIDSet));
+        auto pseudoIDSetDataAddress = pseudoIDSetAddress.withOffset(PseudoIdSet::dataMemoryOffset());
+        PseudoIdSet value { dynamicPseudo };
+        m_assembler.store32(Assembler::TrustedImm32(value.data()), pseudoIDSetDataAddress);
     }
 

trunk/Source/WebCore/dom/SelectorQuery.cpp

@@ -119 +119 @@
     selectorCheckingContext.scope = rootNode.isDocumentNode() ? nullptr : &rootNode;
     unsigned ignoredSpecificity;
-    return selectorChecker.match(selectorData.selector, &element, selectorCheckingContext, ignoredSpecificity);
+    return selectorChecker.match(*selectorData.selector, element, selectorCheckingContext, ignoredSpecificity);
 }
 
@@ -127 +127 @@
     SelectorChecker::CheckingContext selectorCheckingContext(SelectorChecker::Mode::QueryingRules);
     selectorCheckingContext.scope = rootNode.isDocumentNode() ? nullptr : &rootNode;
-    Element* currentNode = &element;
     unsigned ignoredSpecificity;
-    if (!selectorChecker.match(selectorData.selector, currentNode, selectorCheckingContext, ignoredSpecificity))
+    if (!selectorChecker.match(*selectorData.selector, element, selectorCheckingContext, ignoredSpecificity))
         return nullptr;
-    return currentNode;
+    return &element;
 }
 

trunk/Source/WebCore/inspector/InspectorCSSAgent.cpp

@@ -1051 +1051 @@
         for (const CSSSelector* selector = selectorList.first(); selector; selector = CSSSelectorList::next(selector)) {
             unsigned ignoredSpecificity;
-            bool matched = selectorChecker.match(selector, element, context, ignoredSpecificity);
+            bool matched = selectorChecker.match(*selector, *element, context, ignoredSpecificity);
             if (matched)
                 matchingSelectors->addItem(index);

trunk/Source/WebCore/inspector/InspectorStyleSheet.cpp

@@ -863 +863 @@
 
         unsigned specificity;
-        bool okay = selectorChecker.match(&selector, element, context, specificity);
+        bool okay = selectorChecker.match(selector, *element, context, specificity);
         if (!okay)
             specificity = selector.staticSpecificity(okay);

trunk/Source/WebCore/rendering/style/RenderStyleConstants.h

@@ -140 +140 @@
 
     unsigned data() const { return m_data; }
+
+    static ptrdiff_t dataMemoryOffset() { return OBJECT_OFFSETOF(PseudoIdSet, m_data); }
+
 private:
     explicit PseudoIdSet(unsigned rawPseudoIdSet)