Title: [207790] trunk/Source/WebCore
Revision
207790
Author
[email protected]
Date
2016-10-24 17:11:38 -0700 (Mon, 24 Oct 2016)

Log Message

Unreviewed, rolling out r207783.

This change appears to have caused fast/selectors/invalid-
functional-pseudo-class.html to crash on iOS and macOS

Reverted changeset:

"[CSS Parser] Fix :lang argument parsing"
https://bugs.webkit.org/show_bug.cgi?id=163913
http://trac.webkit.org/changeset/207783

Modified Paths

Diff

Modified: trunk/Source/WebCore/ChangeLog (207789 => 207790)


--- trunk/Source/WebCore/ChangeLog	2016-10-25 00:07:15 UTC (rev 207789)
+++ trunk/Source/WebCore/ChangeLog	2016-10-25 00:11:38 UTC (rev 207790)
@@ -1,3 +1,16 @@
+2016-10-24  Ryan Haddad  <[email protected]>
+
+        Unreviewed, rolling out r207783.
+
+        This change appears to have caused fast/selectors/invalid-
+        functional-pseudo-class.html to crash on iOS and macOS
+
+        Reverted changeset:
+
+        "[CSS Parser] Fix :lang argument parsing"
+        https://bugs.webkit.org/show_bug.cgi?id=163913
+        http://trac.webkit.org/changeset/207783
+
 2016-10-24  Brady Eidson  <[email protected]>
 
         IndexedDB 2.0: Support new IDBKeyRange interfaces.

Modified: trunk/Source/WebCore/css/SelectorPseudoClassAndCompatibilityElementMap.in (207789 => 207790)


--- trunk/Source/WebCore/css/SelectorPseudoClassAndCompatibilityElementMap.in	2016-10-25 00:07:15 UTC (rev 207789)
+++ trunk/Source/WebCore/css/SelectorPseudoClassAndCompatibilityElementMap.in	2016-10-25 00:11:38 UTC (rev 207790)
@@ -1,5 +1,4 @@
 -khtml-drag
--webkit-any
 -webkit-any(
 -webkit-any-link, PseudoClassAnyLinkDeprecated, PseudoElementUnknown
 -webkit-autofill
@@ -14,7 +13,6 @@
 decrement
 default
 #if ENABLE(CSS_SELECTORS_LEVEL4)
-dir
 dir(
 #endif
 disabled
@@ -35,23 +33,16 @@
 increment
 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
 only-of-type
@@ -62,7 +53,6 @@
 read-write
 required
 #if ENABLE(CSS_SELECTORS_LEVEL4)
-role
 role(
 #endif
 root

Modified: trunk/Source/WebCore/css/parser/CSSParserValues.cpp (207789 => 207790)


--- trunk/Source/WebCore/css/parser/CSSParserValues.cpp	2016-10-25 00:07:15 UTC (rev 207789)
+++ trunk/Source/WebCore/css/parser/CSSParserValues.cpp	2016-10-25 00:11:38 UTC (rev 207790)
@@ -410,13 +410,7 @@
         argumentList->append(languageArgument);
     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)
 {
     m_selector->setSelectorList(WTFMove(selectorList));

Modified: trunk/Source/WebCore/css/parser/CSSParserValues.h (207789 => 207790)


--- trunk/Source/WebCore/css/parser/CSSParserValues.h	2016-10-25 00:07:15 UTC (rev 207789)
+++ trunk/Source/WebCore/css/parser/CSSParserValues.h	2016-10-25 00:11:38 UTC (rev 207790)
@@ -235,7 +235,6 @@
 
     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>);
 
     void setPseudoClassValue(const CSSParserString& pseudoClassString);

Modified: trunk/Source/WebCore/css/parser/CSSSelectorParser.cpp (207789 => 207790)


--- trunk/Source/WebCore/css/parser/CSSSelectorParser.cpp	2016-10-25 00:07:15 UTC (rev 207789)
+++ trunk/Source/WebCore/css/parser/CSSSelectorParser.cpp	2016-10-25 00:11:38 UTC (rev 207790)
@@ -100,23 +100,6 @@
     return list;
 }
 
-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 {
 
 enum CompoundSelectorFlags {
@@ -486,84 +469,79 @@
     if (token.type() != FunctionToken)
         return nullptr;
 
-    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;
-        }
+    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;
     }
-    
-    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);
+    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;
+    }
 
-            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;
-        }
+    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;
+    }
+
     return nullptr;
 }
 
_______________________________________________
webkit-changes mailing list
[email protected]
https://lists.webkit.org/mailman/listinfo/webkit-changes

Reply via email to