Changeset 85077 in webkit

Timestamp:

Apr 27, 2011 1:32:16 PM (13 years ago)

Author:

Dimitri Glazkov

Message:

2011-04-16 Dimitri Glazkov <Dimitri Glazkov>

Reviewed by Antti Koivisto.

Teach sub-selector chains about shadow descendants
​https://bugs.webkit.org/show_bug.cgi?id=58342

• fast/css/unknown-pseudo-element-matching-expected.txt: Updated expectations.
• fast/css/unknown-pseudo-element-matching.html: Added new tests.

2011-04-20 Dimitri Glazkov <Dimitri Glazkov>

Reviewed by Antti Koivisto.

Teach sub-selector chains about shadow descendants
​https://bugs.webkit.org/show_bug.cgi?id=58342

The primary change is to the logic of parsing specifiers:
1) The shadow descendant selectors (those specifiers that are unknown
pseudo element selectors) are always kept at the top of the chain.
2) The sub-selectors after shadow descendant selectors are stashed right
behind the sub-selector, but not at the end of the chain.
3) Other sub-selectors are appended at the end of the chain.

• css/CSSGrammar.y: Changed specifier_list collection to use new

CSSParser::updateSpecifier helper.

• css/CSSParser.cpp: (WebCore::CSSParser::updateSpecifiersWithElementName): Added logic to

look for the last ShadowDescendant relation in the chain of selectors,
because the next selector after it is the one that should get the
element name.

(WebCore::CSSParser::updateSpecifiers): Moved and modified the logic from

CSSGrammar.y. The new logic adjusts the selector chain to allow
shadow descendant selectors have sub-selectors (and have multiple shadow
descendants in the chain).

• css/CSSParser.h: Added decl.
• css/CSSParserValues.cpp: (WebCore::CSSParserSelector::insertTagHistory): Added. (WebCore::CSSParserSelector::appendTagHistory): Aded.
• css/CSSParserValues.h: Added decls.
• css/CSSStyleSelector.cpp: (WebCore::CSSStyleSelector::SelectorChecker::checkOneSelector): Added

shadow descendant selector match check, since now there could be many
of them in the selector chain.

Location:

trunk

Files:

• LayoutTests/ChangeLog (modified) (1 diff)
• LayoutTests/fast/css/unknown-pseudo-element-matching-expected.txt (modified) (2 diffs)
• LayoutTests/fast/css/unknown-pseudo-element-matching.html (modified) (4 diffs)
• Source/WebCore/ChangeLog (modified) (1 diff)
• Source/WebCore/css/CSSGrammar.y (modified) (1 diff)
• Source/WebCore/css/CSSParser.cpp (modified) (2 diffs)
• Source/WebCore/css/CSSParser.h (modified) (1 diff)
• Source/WebCore/css/CSSParserValues.cpp (modified) (1 diff)
• Source/WebCore/css/CSSParserValues.h (modified) (2 diffs)
• Source/WebCore/css/CSSStyleSelector.cpp (modified) (1 diff)

trunk/LayoutTests/ChangeLog

@@ +1 @@
+2011-04-16  Dimitri Glazkov  <dglazkov@chromium.org>
+
+        Reviewed by Antti Koivisto.
+
+        Teach sub-selector chains about shadow descendants
+        https://bugs.webkit.org/show_bug.cgi?id=58342
+
+        * fast/css/unknown-pseudo-element-matching-expected.txt: Updated expectations.
+        * fast/css/unknown-pseudo-element-matching.html: Added new tests.
+
 2011-04-20  Adrienne Walker  <enne@google.com>
 

trunk/LayoutTests/fast/css/unknown-pseudo-element-matching-expected.txt

@@ -1 +1 @@
 Tests various selector combinations, containing unknown pseudo element selectors.
 
+Basic selector tests:
 ::-webkit-slider-thumb should match: PASS
 ::-webkit-slider-thumb, where HTML is not default namespace should not match: PASS
@@ -25 +26 @@
 input#foo[type=range]::-webkit-slider-thumb should match: PASS
 input.bar[type=range]::-webkit-slider-thumb should match: PASS
+
+Shouldn't ignore selector after the unknown pseudo element:
+::-webkit-slider-thumb:disabled should not match: PASS
+input::-webkit-slider-thumb:disabled should not match: PASS
+#foo::-webkit-slider-thumb:disabled should not match: PASS
+input#foo::-webkit-slider-thumb:disabled should not match: PASS
+input.bar::-webkit-slider-thumb:disabled should not match: PASS
+input[type=range]::-webkit-slider-thumb:disabled should not match: PASS
+
+Should not match disabled input, because the disabled state is on the input, not the thumb:
+::-webkit-slider-thumb:disabled should not match: PASS
+input::-webkit-slider-thumb:disabled should not match: PASS
+#foo::-webkit-slider-thumb:disabled should not match: PASS
+input#foo::-webkit-slider-thumb:disabled should not match: PASS
+input.bar::-webkit-slider-thumb:disabled should not match: PASS
+input[type=range]::-webkit-slider-thumb:disabled should not match: PASS
+
+Should match :hover when the mouse is over the slider thumb:
+::-webkit-slider-thumb:hover should match: PASS
+input::-webkit-slider-thumb:hover should match: PASS
+#foo::-webkit-slider-thumb:hover should match: PASS
+input#foo::-webkit-slider-thumb:hover should match: PASS
+input.bar::-webkit-slider-thumb:hover should match: PASS
+input[type=range]::-webkit-slider-thumb:hover should match: PASS

trunk/LayoutTests/fast/css/unknown-pseudo-element-matching.html

@@ -17 +17 @@
 var NAMESPACE_DECLARATION = '@namespace "http://example.com/foo/namespace";\n@namespace html "http://www.w3.org/1999/xhtml";\n';
 var SELECTOR_TEST_PROPERTIES = ' { height: 1px; -webkit-appearance: none; }';
+var SELECTORS = [
+'::-webkit-slider-thumb',
+'input::-webkit-slider-thumb',
+'#foo::-webkit-slider-thumb',
+'input#foo::-webkit-slider-thumb',
+'input.bar::-webkit-slider-thumb',
+'input[type=range]::-webkit-slider-thumb'
+];
+var DISABLED_SELECTORS = SELECTORS.map(function(selector) { return selector + ':disabled'; });
+var HOVER_SELECTORS = SELECTORS.map(function(selector) { return selector + ':hover'; })
 
 // convenience constants
@@ -25 +35 @@
 function log(msg, success)
 {
-    logDiv.appendChild(document.createElement('div')).innerHTML = msg + ': ' + (success ? 'PASS' : 'FAIL');
+    logDiv.appendChild(document.createElement('div')).innerHTML = msg + (arguments.length == 1 ? '' : (': ' + (success ? 'PASS' : 'FAIL')));
+}
+
+function hoverOverSliderThumb()
+{
+    if (!window.eventSender)
+        return false;
+
+    var x = input.offsetLeft + input.offsetWidth / 2;
+    var y = input.offsetTop + input.offsetHeight / 2;
+    eventSender.mouseMoveTo(x, y);
+    return true;
 }
 
@@ -43 +64 @@
     input = document.getElementsByTagName('input')[0];
     logDiv = document.getElementById('log');
+    log('Basic selector tests:');
     runSelectorTest(MATCH, '::-webkit-slider-thumb');
     runSelectorTest(NO_MATCH, '::-webkit-slider-thumb', WITH_NAMESPACES);
@@ -67 +89 @@
     runSelectorTest(MATCH, 'input#foo[type=range]::-webkit-slider-thumb');
     runSelectorTest(MATCH, 'input.bar[type=range]::-webkit-slider-thumb');
+    log('<br>Shouldn\'t ignore selector after the unknown pseudo element:');
+    DISABLED_SELECTORS.forEach(expectNoMatch);
+    input.disabled = true;
+    log('<br>Should not match disabled input, because the disabled state is on the input, not the thumb:');
+    DISABLED_SELECTORS.forEach(expectNoMatch);
+    input.disabled = false;
+    if (!hoverOverSliderThumb()) {
+        log(':hover tests require DRT');
+        return;
+    }
+    log('<br>Should match :hover when the mouse is over the slider thumb:');
+    HOVER_SELECTORS.forEach(expectMatch);
     document.body.removeChild(input);
+}
+
+function expectNoMatch(selector) {
+    runSelectorTest(NO_MATCH, selector);
+}
+
+function expectMatch(selector) {
+    runSelectorTest(MATCH, selector);
 }
 

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2011-04-20  Dimitri Glazkov  <dglazkov@chromium.org>
+
+        Reviewed by Antti Koivisto.
+
+        Teach sub-selector chains about shadow descendants
+        https://bugs.webkit.org/show_bug.cgi?id=58342
+
+        The primary change is to the logic of parsing specifiers:
+        1) The shadow descendant selectors (those specifiers that are unknown
+        pseudo element selectors) are always kept at the top of the chain.
+        2) The sub-selectors after shadow descendant selectors are stashed right
+        behind the sub-selector, but not at the end of the chain.
+        3) Other sub-selectors are appended at the end of the chain.
+
+        * css/CSSGrammar.y: Changed specifier_list collection to use new
+            CSSParser::updateSpecifier helper.
+        * css/CSSParser.cpp:
+        (WebCore::CSSParser::updateSpecifiersWithElementName): Added logic to
+            look for the last ShadowDescendant relation in the chain of selectors,
+            because the next selector after it is the one that should get the
+            element name.
+        (WebCore::CSSParser::updateSpecifiers): Moved and modified the logic from
+            CSSGrammar.y. The new logic adjusts the selector chain to allow
+            shadow descendant selectors have sub-selectors (and have multiple shadow
+            descendants in the chain).
+        * css/CSSParser.h: Added decl.
+        * css/CSSParserValues.cpp:
+        (WebCore::CSSParserSelector::insertTagHistory): Added.
+        (WebCore::CSSParserSelector::appendTagHistory): Aded.
+        * css/CSSParserValues.h: Added decls.
+        * css/CSSStyleSelector.cpp:
+        (WebCore::CSSStyleSelector::SelectorChecker::checkOneSelector): Added
+            shadow descendant selector match check, since now there could be many
+            of them in the selector chain.
+
 2011-04-20  Adrienne Walker  <enne@google.com>
 

trunk/Source/WebCore/css/CSSGrammar.y

@@ -980 +980 @@
         if (!$2)
             $$ = 0;
-        else if ($1) {
-            CSSParser* p = static_cast<CSSParser*>(parser);
-            CSSParserSelector* end;
-            CSSParserSelector* history;
-            // Ensure that unknown pseudo element always stays at the top of selector chain.
-            if ($2->isUnknownPseudoElement()) {
-                end = $2;
-                history = $1;
-            } else {
-                end = $1;
-                history = $2;
-            }
-            $$ = end;
-            while(end->tagHistory())
-                end = end->tagHistory();
-            end->setRelation(CSSSelector::SubSelector);
-            end->setTagHistory(p->sinkFloatingSelector(history));
-        }
+        else if ($1)
+            $$ = static_cast<CSSParser*>(parser)->updateSpecifiers($1, $2);
     }
     | specifier_list error {

trunk/Source/WebCore/css/CSSParser.cpp

@@ -6370 +6370 @@
     }
 
-    specifiers->setRelation(CSSSelector::ShadowDescendant);
-    if (CSSParserSelector* history = specifiers->tagHistory()) {
-        history->setTag(tag);
+    CSSParserSelector* lastShadowDescendant = specifiers;
+    CSSParserSelector* history = specifiers;
+    while (history->tagHistory()) {
+        history = history->tagHistory();
+        if (history->hasShadowDescendant())
+            lastShadowDescendant = history;
+    }
+
+    if (lastShadowDescendant->tagHistory()) {
+        lastShadowDescendant->tagHistory()->setTag(tag);
         return;
     }
@@ -6383 +6390 @@
     CSSParserSelector* elementNameSelector = new CSSParserSelector;
     elementNameSelector->setTag(tag);
-    specifiers->setTagHistory(elementNameSelector);
-}
-
+    lastShadowDescendant->setTagHistory(elementNameSelector);
+    lastShadowDescendant->setRelation(CSSSelector::ShadowDescendant);
+}
+
+CSSParserSelector* CSSParser::updateSpecifiers(CSSParserSelector* specifiers, CSSParserSelector* newSpecifier)
+{
+    if (newSpecifier->isUnknownPseudoElement()) {
+        // Unknown pseudo element always goes at the top of selector chain.
+        newSpecifier->appendTagHistory(CSSSelector::ShadowDescendant, sinkFloatingSelector(specifiers));
+        return newSpecifier;
+    }
+    if (specifiers->isUnknownPseudoElement()) {
+        // Specifiers for unknown pseudo element go right behind it in the chain.
+        specifiers->insertTagHistory(CSSSelector::SubSelector, sinkFloatingSelector(newSpecifier), CSSSelector::ShadowDescendant);
+        return specifiers;
+    }
+    specifiers->appendTagHistory(CSSSelector::SubSelector, sinkFloatingSelector(newSpecifier));
+    return specifiers;
+}
 
 CSSRule* CSSParser::createPageRule(PassOwnPtr<CSSParserSelector> pageSelector)

trunk/Source/WebCore/css/CSSParser.h

@@ -221 +221 @@
         void addNamespace(const AtomicString& prefix, const AtomicString& uri);
         void updateSpecifiersWithElementName(const AtomicString& namespacePrefix, const AtomicString& elementName, CSSParserSelector*);
+        CSSParserSelector* updateSpecifiers(CSSParserSelector*, CSSParserSelector*);
 
         void invalidBlockHit();

trunk/Source/WebCore/css/CSSParserValues.cpp

@@ -115 +115 @@
     m_selector->setSelectorList(adoptPtr(selectorList));
 }
+
+void CSSParserSelector::insertTagHistory(CSSSelector::Relation before, PassOwnPtr<CSSParserSelector> selector, CSSSelector::Relation after)
+{
+    if (m_tagHistory)
+        selector->setTagHistory(m_tagHistory.release());
+    setRelation(before);
+    selector->setRelation(after);
+    m_tagHistory = selector;
 }
 
+void CSSParserSelector::appendTagHistory(CSSSelector::Relation relation, PassOwnPtr<CSSParserSelector> selector)
+{
+    CSSParserSelector* end = this;
+    while (end->tagHistory())
+        end = end->tagHistory();
+    end->setRelation(relation);
+    end->setTagHistory(selector);
+}
+
+}
+

trunk/Source/WebCore/css/CSSParserValues.h

@@ -117 +117 @@
     bool isUnknownPseudoElement() const { return m_selector->isUnknownPseudoElement(); }
     bool isSimple() const { return !m_tagHistory && m_selector->isSimple(); }
+    bool hasShadowDescendant() const;
 
     CSSParserSelector* tagHistory() const { return m_tagHistory.get(); }
     void setTagHistory(PassOwnPtr<CSSParserSelector> selector) { m_tagHistory = selector; }
+    void insertTagHistory(CSSSelector::Relation before, PassOwnPtr<CSSParserSelector>, CSSSelector::Relation after);
+    void appendTagHistory(CSSSelector::Relation, PassOwnPtr<CSSParserSelector>);
 
 private:
@@ -126 +129 @@
 };
 
+inline bool CSSParserSelector::hasShadowDescendant() const
+{
+    return m_selector->relation() == CSSSelector::ShadowDescendant;
+}
+
 }
 

trunk/Source/WebCore/css/CSSStyleSelector.cpp

@@ -2967 +2967 @@
             return false;
 
-        if (sel->isUnknownPseudoElement())
+        if (sel->isUnknownPseudoElement()) {
             m_hasUnknownPseudoElements = true;
+            return e->shadowPseudoId() == sel->value();
+        }
 
         PseudoId pseudoId = CSSSelector::pseudoId(sel->pseudoType());