DevTools: matched styles respect :visited/:link pseudo classes

Source/core/inspector/InspectorCSSAgent.cpp

Index: Source/core/inspector/InspectorCSSAgent.cpp
diff --git a/Source/core/inspector/InspectorCSSAgent.cpp b/Source/core/inspector/InspectorCSSAgent.cpp
index d79f534115c5a40cb6856c9071ec9fba204f4891..2c984d4bbfc6f8de7098b07535db705e76e82dfe 100644
--- a/Source/core/inspector/InspectorCSSAgent.cpp
+++ b/Source/core/inspector/InspectorCSSAgent.cpp
@@ -48,6 +48,7 @@
 #include "core/css/resolver/StyleResolver.h"
 #include "core/dom/Node.h"
 #include "core/dom/NodeList.h"
+#include "core/dom/VisitedLinkState.h"
 #include "core/fetch/CSSStyleSheetResource.h"
 #include "core/fetch/ResourceClient.h"
 #include "core/fetch/ResourceFetcher.h"
@@ -65,6 +66,7 @@
 #include "core/rendering/RenderObject.h"
 #include "core/rendering/RenderText.h"
 #include "core/rendering/RenderTextFragment.h"
+#include "core/rendering/style/RenderStyleConstants.h"
 #include "platform/fonts/Font.h"
 #include "platform/fonts/GlyphBuffer.h"
 #include "platform/fonts/WidthIterator.h"
@@ -686,7 +688,7 @@ void InspectorCSSAgent::getMatchedStylesForNode(ErrorString* errorString, int no
     StyleResolver& styleResolver = ownerDocument->ensureStyleResolver();
 
     RefPtrWillBeRawPtr<CSSRuleList> matchedRules = styleResolver.pseudoCSSRulesForElement(element, elementPseudoId, StyleResolver::AllCSSRules);
-    matchedCSSRules = buildArrayForMatchedRuleList(matchedRules.get(), originalElement);
+    matchedCSSRules = buildArrayForMatchedRuleList(matchedRules.get(), originalElement, true);
 
     // Pseudo elements.
     if (!elementPseudoId && (!includePseudo || *includePseudo)) {
@@ -696,7 +698,7 @@ void InspectorCSSAgent::getMatchedStylesForNode(ErrorString* errorString, int no
             if (matchedRules && matchedRules->length()) {
                 RefPtr<TypeBuilder::CSS::PseudoIdMatches> matches = TypeBuilder::CSS::PseudoIdMatches::create()
                     .setPseudoId(static_cast<int>(pseudoId))
-                    .setMatches(buildArrayForMatchedRuleList(matchedRules.get(), element));
+                    .setMatches(buildArrayForMatchedRuleList(matchedRules.get(), element, false));
                 pseudoElements->addItem(matches.release());
             }
         }
@@ -712,7 +714,7 @@ void InspectorCSSAgent::getMatchedStylesForNode(ErrorString* errorString, int no
             StyleResolver& parentStyleResolver = parentElement->ownerDocument()->ensureStyleResolver();
             RefPtrWillBeRawPtr<CSSRuleList> parentMatchedRules = parentStyleResolver.cssRulesForElement(parentElement, StyleResolver::AllCSSRules);
             RefPtr<TypeBuilder::CSS::InheritedStyleEntry> entry = TypeBuilder::CSS::InheritedStyleEntry::create()
-                .setMatchedCSSRules(buildArrayForMatchedRuleList(parentMatchedRules.get(), parentElement));
+                .setMatchedCSSRules(buildArrayForMatchedRuleList(parentMatchedRules.get(), parentElement, true));
             if (parentElement->style() && parentElement->style()->length()) {
                 InspectorStyleSheetForInlineStyle* styleSheet = asInspectorStyleSheet(parentElement);
                 if (styleSheet)
@@ -1294,12 +1296,35 @@ static inline bool matchesPseudoElement(const CSSSelector* selector, PseudoId el
     return selectorPseudoId == elementPseudoId;
 }
 
-PassRefPtr<TypeBuilder::Array<TypeBuilder::CSS::RuleMatch> > InspectorCSSAgent::buildArrayForMatchedRuleList(CSSRuleList* ruleList, Element* element)
+static inline bool matchesElement(const CSSSelector& selector, Element& element)
+{
+    SelectorChecker selectorChecker(element.document(), SelectorChecker::QueryingRules);
+    SelectorChecker::SelectorCheckingContext selectorCheckingContext(selector, &element, SelectorChecker::VisitedMatchEnabled);
+    selectorCheckingContext.behaviorAtBoundary = SelectorChecker::StaysWithinTreeScope;
+    selectorCheckingContext.scope = !element.isDocumentNode() ? &element : 0;
+    return selectorChecker.match(selectorCheckingContext, DOMSiblingTraversalStrategy()) == SelectorChecker::SelectorMatches;
+}
+
+EInsideLink InspectorCSSAgent::linkStateForElement(Element* element)
+{
+    EInsideLink linkState = NotInsideLink;
+    if (element->isLink()) {
+        VisitedLinkState& visitedLinkState = element->ownerDocument()->visitedLinkState();
+        linkState = visitedLinkState.determineLinkState(*element);
+        bool forceVisited = forcePseudoState(element, CSSSelector::PseudoVisited);
+        if (forceVisited)
+            linkState = InsideVisitedLink;
+    }
+    return linkState;
+}
+
+PassRefPtr<TypeBuilder::Array<TypeBuilder::CSS::RuleMatch> > InspectorCSSAgent::buildArrayForMatchedRuleList(CSSRuleList* ruleList, Element* element, bool skipRulesWithoutMatchedSelectors)

[apavlov, 2014/04/08 16:59:51]

Blink typically uses enums to clarify boolean argument semantics.

 {
     RefPtr<TypeBuilder::Array<TypeBuilder::CSS::RuleMatch> > result = TypeBuilder::Array<TypeBuilder::CSS::RuleMatch>::create();
     if (!ruleList)
         return result.release();
 
+    EInsideLink linkState = linkStateForElement(element);
     for (unsigned i = 0, size = ruleList->length(); i < size; ++i) {
         CSSStyleRule* rule = asCSSStyleRule(ruleList->item(i));
         RefPtr<TypeBuilder::CSS::CSSRule> ruleObject = buildObjectForRule(rule);
@@ -1309,16 +1334,30 @@ PassRefPtr<TypeBuilder::Array<TypeBuilder::CSS::RuleMatch> > InspectorCSSAgent::
         const CSSSelectorList& selectorList = rule->styleRule()->selectorList();
         long index = 0;
         PseudoId elementPseudoId = element->pseudoId();
+        bool hasMatchingSelectors = false;
         for (const CSSSelector* selector = selectorList.first(); selector; selector = CSSSelectorList::next(*selector)) {
             const CSSSelector* firstTagHistorySelector = selector;
-            bool matched = false;
+            bool matchedPseudo = false;
             if (elementPseudoId)
-                matched = matchesPseudoElement(selector, elementPseudoId); // Modifies |selector|.
-            matched |= element->matches(firstTagHistorySelector->selectorText(), IGNORE_EXCEPTION);
-            if (matched)
+                matchedPseudo = matchesPseudoElement(selector, elementPseudoId); // Modifies |selector|.
+
+            bool matchedElement = matchesElement(*firstTagHistorySelector, *element);
+            if (matchedElement) {
+                unsigned linkMatchType = SelectorChecker::determineLinkMatchType(*firstTagHistorySelector);
+                if (linkState == InsideUnvisitedLink)
+                    matchedElement = linkMatchType & SelectorChecker::MatchLink;
+                else if (linkState == InsideVisitedLink)
+                    matchedElement = linkMatchType & SelectorChecker::MatchVisited;
+            }
+
+            if (matchedPseudo || matchedElement) {
                 matchingSelectors->addItem(index);
+                hasMatchingSelectors = true;
+            }
             ++index;
         }
+        if (skipRulesWithoutMatchedSelectors && !hasMatchingSelectors)
+            continue;
         RefPtr<TypeBuilder::CSS::RuleMatch> match = TypeBuilder::CSS::RuleMatch::create()
             .setRule(ruleObject.release())
             .setMatchingSelectors(matchingSelectors.release());