Changeset 207783 in webkit

Timestamp:

Oct 24, 2016 2:51:44 PM (7 years ago)

Author:

hyatt@apple.com

Message:

[CSS Parser] Fix :lang argument parsing
​https://bugs.webkit.org/show_bug.cgi?id=163913

Reviewed by Zalan Bujtas.

• css/SelectorPseudoClassAndCompatibilityElementMap.in:

Modify the map to support versions of the function pseudos
without the left paren included.

• css/parser/CSSParserValues.cpp:

(WebCore::CSSParserSelector::setLangArgumentList):

• css/parser/CSSParserValues.h:

Add a helper to just directly pass an AtomicString Vector through.

• css/parser/CSSSelectorParser.cpp:

(WebCore::consumeLangArgumentList):
(WebCore::CSSSelectorParser::consumePseudo):
Add a new consumeLangArgumentList to collect the languages into
an AtomicString Vector.

Location:

trunk/Source/WebCore

Files:

• ChangeLog (modified) (1 diff)
• css/SelectorPseudoClassAndCompatibilityElementMap.in (modified) (4 diffs)
• css/parser/CSSParserValues.cpp (modified) (1 diff)
• css/parser/CSSParserValues.h (modified) (1 diff)
• css/parser/CSSSelectorParser.cpp (modified) (2 diffs)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2016-10-24  Dave Hyatt  <hyatt@apple.com>
+
+        [CSS Parser] Fix :lang argument parsing
+        https://bugs.webkit.org/show_bug.cgi?id=163913
+
+        Reviewed by Zalan Bujtas.
+
+        * css/SelectorPseudoClassAndCompatibilityElementMap.in:
+        Modify the map to support versions of the function pseudos
+        without the left paren included.
+
+        * css/parser/CSSParserValues.cpp:
+        (WebCore::CSSParserSelector::setLangArgumentList):
+        * css/parser/CSSParserValues.h:
+        Add a helper to just directly pass an AtomicString Vector through.
+
+        * css/parser/CSSSelectorParser.cpp:
+        (WebCore::consumeLangArgumentList):
+        (WebCore::CSSSelectorParser::consumePseudo):
+        Add a new consumeLangArgumentList to collect the languages into
+        an AtomicString Vector.
+
 2016-10-24  Alex Christensen  <achristensen@webkit.org>
 

trunk/Source/WebCore/css/SelectorPseudoClassAndCompatibilityElementMap.in

@@ -1 +1 @@
 -khtml-drag
+-webkit-any
 -webkit-any(
 -webkit-any-link, PseudoClassAnyLinkDeprecated, PseudoElementUnknown
@@ -14 +15 @@
 default
 #if ENABLE(CSS_SELECTORS_LEVEL4)
+dir
 dir(
 #endif
@@ -34 +36 @@
 indeterminate
 invalid
+lang
 lang(
 last-child
 last-of-type
 link
+matches
 matches(
 no-button
+not
 not(
+nth-child
 nth-child(
+nth-last-child
 nth-last-child(
+nth-last-of-type
 nth-last-of-type(
+nth-of-type
 nth-of-type(
 only-child
@@ -54 +63 @@
 required
 #if ENABLE(CSS_SELECTORS_LEVEL4)
+role
 role(
 #endif

trunk/Source/WebCore/css/parser/CSSParserValues.cpp

@@ -411 +411 @@
     m_selector->setLangArgumentList(WTFMove(argumentList));
 }
-    
+
+void CSSParserSelector::setLangArgumentList(std::unique_ptr<Vector<AtomicString>> argumentList)
+{
+    ASSERT_WITH_MESSAGE(!argumentList->isEmpty(), "No CSS Selector takes an empty argument list.");
+    m_selector->setLangArgumentList(WTFMove(argumentList));
+}
+
 void CSSParserSelector::setSelectorList(std::unique_ptr<CSSSelectorList> selectorList)
 {

trunk/Source/WebCore/css/parser/CSSParserValues.h

@@ -236 +236 @@
     void adoptSelectorVector(Vector<std::unique_ptr<CSSParserSelector>>& selectorVector);
     void setLangArgumentList(const Vector<CSSParserString>& stringVector);
+    void setLangArgumentList(std::unique_ptr<Vector<AtomicString>>);
     void setSelectorList(std::unique_ptr<CSSSelectorList>);
 

trunk/Source/WebCore/css/parser/CSSSelectorParser.cpp

@@ -101 +101 @@
 }
 
+static void consumeLangArgumentList(std::unique_ptr<Vector<AtomicString>>& argumentList, CSSParserTokenRange& range)
+{
+    const CSSParserToken& ident = range.consumeIncludingWhitespace();
+    if (ident.type() != IdentToken)
+        return;
+    argumentList->append(ident.value().toAtomicString());
+    while (!range.atEnd() && range.peek().type() == CommaToken) {
+        range.consumeIncludingWhitespace();
+        const CSSParserToken& ident = range.consumeIncludingWhitespace();
+        if (ident.type() != IdentToken) {
+            argumentList->clear();
+            return;
+        }
+        argumentList->append(ident.value().toAtomicString());
+    }
+}
+    
 namespace {
 
@@ -470 +487 @@
         return nullptr;
 
-    switch (selector->pseudoClassType()) {
-    case CSSSelector::PseudoClassNot: {
-        std::unique_ptr<CSSParserSelector> innerSelector = consumeCompoundSelector(block);
-        block.consumeWhitespace();
-        if (!innerSelector || !block.atEnd())
-            return nullptr;
-        Vector<std::unique_ptr<CSSParserSelector>> selectorVector;
-        selectorVector.append(WTFMove(innerSelector));
-        selector->adoptSelectorVector(selectorVector);
-        return selector;
-    }
-    case CSSSelector::PseudoClassNthChild:
-    case CSSSelector::PseudoClassNthLastChild:
-    case CSSSelector::PseudoClassNthOfType:
-    case CSSSelector::PseudoClassNthLastOfType: {
-        std::pair<int, int> ab;
-        if (!consumeANPlusB(block, ab))
-            return nullptr;
-        block.consumeWhitespace();
-        if (!block.atEnd())
-            return nullptr;
-        selector->setArgument(AtomicString::number(ab.first * ab.second));
-        return selector;
-    }
-    case CSSSelector::PseudoClassLang: {
-        // FIXME: CSS Selectors Level 4 allows :lang(*-foo)
-        const CSSParserToken& ident = block.consumeIncludingWhitespace();
-        if (ident.type() != IdentToken || !block.atEnd())
-            return nullptr;
-        selector->setArgument(ident.value().toAtomicString());
-        return selector;
-    }
-    // FIXME-NEWPARSER: Support :host-context
-    case CSSSelector::PseudoClassAny:
-    case CSSSelector::PseudoClassHost: {
-        DisallowPseudoElementsScope scope(this);
-        std::unique_ptr<CSSSelectorList> selectorList = std::unique_ptr<CSSSelectorList>(new CSSSelectorList());
-        *selectorList = consumeCompoundSelectorList(block);
-        if (!selectorList->isValid() || !block.atEnd())
-            return nullptr;
-        selector->setSelectorList(WTFMove(selectorList));
-        return selector;
-    }
-    default:
-        break;
-    }
-
-    switch (selector->pseudoElementType()) {
-    case CSSSelector::PseudoElementCue: {
-        DisallowPseudoElementsScope scope(this);
-        std::unique_ptr<CSSSelectorList> selectorList = std::unique_ptr<CSSSelectorList>(new CSSSelectorList());
-        *selectorList = consumeCompoundSelectorList(block);
-        if (!selectorList->isValid() || !block.atEnd())
-            return nullptr;
-        selector->setSelectorList(WTFMove(selectorList));
-        return selector;
-    }
-    case CSSSelector::PseudoElementSlotted: {
-        DisallowPseudoElementsScope scope(this);
-
-        std::unique_ptr<CSSParserSelector> innerSelector = consumeCompoundSelector(block);
-        block.consumeWhitespace();
-        if (!innerSelector || !block.atEnd())
-            return nullptr;
-        Vector<std::unique_ptr<CSSParserSelector>> selectorVector;
-        selectorVector.append(WTFMove(innerSelector));
-        selector->adoptSelectorVector(selectorVector);
-        return selector;
-    }
-    default:
-        break;
+    if (selector->match() == CSSSelector::PseudoClass) {
+        switch (selector->pseudoClassType()) {
+        case CSSSelector::PseudoClassNot: {
+            std::unique_ptr<CSSParserSelector> innerSelector = consumeCompoundSelector(block);
+            block.consumeWhitespace();
+            if (!innerSelector || !block.atEnd())
+                return nullptr;
+            Vector<std::unique_ptr<CSSParserSelector>> selectorVector;
+            selectorVector.append(WTFMove(innerSelector));
+            selector->adoptSelectorVector(selectorVector);
+            return selector;
+        }
+        case CSSSelector::PseudoClassNthChild:
+        case CSSSelector::PseudoClassNthLastChild:
+        case CSSSelector::PseudoClassNthOfType:
+        case CSSSelector::PseudoClassNthLastOfType: {
+            std::pair<int, int> ab;
+            if (!consumeANPlusB(block, ab))
+                return nullptr;
+            block.consumeWhitespace();
+            if (!block.atEnd())
+                return nullptr;
+            selector->setArgument(AtomicString::number(ab.first * ab.second));
+            return selector;
+        }
+        case CSSSelector::PseudoClassLang: {
+            // FIXME: CSS Selectors Level 4 allows :lang(*-foo)
+            auto argumentList = std::make_unique<Vector<AtomicString>>();
+            consumeLangArgumentList(argumentList, block);
+            if (argumentList->isEmpty())
+                return nullptr;
+            selector->setLangArgumentList(WTFMove(argumentList));
+            return selector;
+        }
+        // FIXME-NEWPARSER: Support :host-context
+        case CSSSelector::PseudoClassAny:
+        case CSSSelector::PseudoClassHost: {
+            DisallowPseudoElementsScope scope(this);
+            std::unique_ptr<CSSSelectorList> selectorList = std::unique_ptr<CSSSelectorList>(new CSSSelectorList());
+            *selectorList = consumeCompoundSelectorList(block);
+            if (!selectorList->isValid() || !block.atEnd())
+                return nullptr;
+            selector->setSelectorList(WTFMove(selectorList));
+            return selector;
+        }
+        default:
+            break;
+        }
+    }
+    
+    if (selector->match() == CSSSelector::PseudoElement) {
+        switch (selector->pseudoElementType()) {
+        case CSSSelector::PseudoElementCue: {
+            DisallowPseudoElementsScope scope(this);
+            std::unique_ptr<CSSSelectorList> selectorList = std::unique_ptr<CSSSelectorList>(new CSSSelectorList());
+            *selectorList = consumeCompoundSelectorList(block);
+            if (!selectorList->isValid() || !block.atEnd())
+                return nullptr;
+            selector->setSelectorList(WTFMove(selectorList));
+            return selector;
+        }
+        case CSSSelector::PseudoElementSlotted: {
+            DisallowPseudoElementsScope scope(this);
+
+            std::unique_ptr<CSSParserSelector> innerSelector = consumeCompoundSelector(block);
+            block.consumeWhitespace();
+            if (!innerSelector || !block.atEnd())
+                return nullptr;
+            Vector<std::unique_ptr<CSSParserSelector>> selectorVector;
+            selectorVector.append(WTFMove(innerSelector));
+            selector->adoptSelectorVector(selectorVector);
+            return selector;
+        }
+        default:
+            break;
+        }
     }