Merge 97745 - REGRESSION(r97248): :visited as descendant selector broken

Source/WebCore/css/SelectorChecker.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (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 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
  * Copyright (C) 2007, 2008 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (c) 2011, Code Aurora Forum. All rights reserved.
  * Copyright (C) Research In Motion Limited 2011. All rights reserved.
@@ skipping 432 matching lines @@
     if (!checkOneSelector(sel, e, dynamicPseudo, isSubSelector, visitedMatchType, elementStyle, elementParentStyle))
         return SelectorFailsLocally;
     
     // The rest of the selectors has to match
     CSSSelector::Relation relation = sel->relation();
     
     // Prepare next sel
     sel = sel->tagHistory();
     if (!sel)
         return SelectorMatches;
-    
+
     if (relation != CSSSelector::SubSelector) {
         // Bail-out if this selector is irrelevant for the pseudoStyle
         if (m_pseudoStyle != NOPSEUDO && m_pseudoStyle != dynamicPseudo)
             return SelectorFailsCompletely;
     
-        // Disable :visited matching after we move to selector components that would match anything else than the current element.
-        if (!isSubSelector)
+        // Disable :visited matching when we see the first link or try to match anything else than an ancestors.
+        if (!isSubSelector && (e->isLink() || (relation != CSSSelector::Descendant && relation != CSSSelector::Child)))
             visitedMatchType = VisitedMatchDisabled;
     }
-    
+
     switch (relation) {
     case CSSSelector::Descendant:
         while (true) {
             ContainerNode* n = e->parentNode();
             if (!n || !n->isElementNode())
                 return SelectorFailsCompletely;
             e = static_cast<Element*>(n);
             SelectorMatch match = checkSelector(sel, e, dynamicPseudo, false, visitedMatchType);
             if (match != SelectorFailsLocally)
                 return match;
@@ skipping 857 matching lines @@
         ASSERT_NOT_REACHED();
     }
     return true;
 }
 
 unsigned SelectorChecker::determineLinkMatchType(const CSSSelector* selector)
 {
     unsigned linkMatchType = MatchAll;
     
     // Statically determine if this selector will match a link in visited, unvisited or any state, or never.
-    // :visited never matches other elements than the current.
+    // :visited never matches other elements than the innermost link element.
     for (; selector; selector = selector->tagHistory()) {
         switch (selector->pseudoType()) {
         case CSSSelector::PseudoNot:
             // :not(:visited) is equivalent to :link. Parser enforces that :not can't nest.
             for (CSSSelector* subSelector = selector->selectorList()->first(); subSelector; subSelector = subSelector->tagHistory()) {
                 CSSSelector::PseudoType subType = subSelector->pseudoType();
                 if (subType == CSSSelector::PseudoVisited)
                     linkMatchType &= ~SelectorChecker::MatchVisited;
                 else if (subType == CSSSelector::PseudoLink)
                     linkMatchType &= ~SelectorChecker::MatchLink;
             }
             break;
         case CSSSelector::PseudoLink:
             linkMatchType &= ~SelectorChecker::MatchVisited;
             break;
         case CSSSelector::PseudoVisited:
             linkMatchType &= ~SelectorChecker::MatchLink;
             break;
         default:
             // We don't support :link and :visited inside :-webkit-any.
             break;
         }
-        if (selector->relation() != CSSSelector::SubSelector)
+        CSSSelector::Relation relation = selector->relation();
+        if (relation == CSSSelector::SubSelector)
+            continue;
+        if (relation != CSSSelector::Descendant && relation != CSSSelector::Child)
+            return linkMatchType;
+        if (linkMatchType != MatchAll)
             return linkMatchType;
     }
-    ASSERT_NOT_REACHED();
     return linkMatchType;
 }
 
 bool SelectorChecker::isFrameFocused(const Element* element)
 {
     return element->document()->frame() && element->document()->frame()->selection()->isFocusedAndActive();
 }
 
 }