Restrict use of pseudo elements within compound.

third_party/WebKit/Source/core/css/parser/CSSSelectorParserTest.cpp

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/css/parser/CSSSelectorParser.h"
 
 #include "core/css/CSSSelectorList.h"
 #include "core/css/parser/CSSTokenizer.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 52 matching lines @@
 
         {"29N + 77", 29, 77},
         {"29n - 77", 29, -77},
         {"+n + 61", 1, 61},
         {"+N - 63", 1, -63},
         {"+n/**/- 48", 1, -48},
         {"-n + 81", -1, 81},
         {"-N - 88", -1, -88},
     };
 
-    for (unsigned i = 0; i < WTF_ARRAY_LENGTH(testCases); ++i) {
-        SCOPED_TRACE(testCases[i].input);
+    for (auto testCase : testCases) {
+        SCOPED_TRACE(testCase.input);
 
         std::pair<int, int> ab;
-        CSSTokenizer::Scope scope(testCases[i].input);
+        CSSTokenizer::Scope scope(testCase.input);
         CSSParserTokenRange range = scope.tokenRange();
         bool passed = CSSSelectorParser::consumeANPlusB(range, ab);
         EXPECT_TRUE(passed);
-        EXPECT_EQ(ab.first, testCases[i].a);
-        EXPECT_EQ(ab.second, testCases[i].b);
+        EXPECT_EQ(ab.first, testCase.a);
+        EXPECT_EQ(ab.second, testCase.b);
     }
 }
 
 TEST(CSSSelectorParserTest, InvalidANPlusB)
 {
     // Some of these have token range prefixes which are valid <an+b> and could
     // in theory be valid in consumeANPlusB, but this behaviour isn't needed
     // anywhere and not implemented.
     const char* testCases[] = {
         " odd",
         "+ n",
         "3m+4",
         "12n--34",
         "12n- -34",
         "12n- +34",
         "23n-+43",
         "10n 5",
         "10n + +5",
         "10n + -5",
     };
 
-    for (unsigned i = 0; i < WTF_ARRAY_LENGTH(testCases); ++i) {
-        SCOPED_TRACE(testCases[i]);
+    for (auto testCase : testCases) {
+        SCOPED_TRACE(testCase);
 
         std::pair<int, int> ab;
-        CSSTokenizer::Scope scope(testCases[i]);
+        CSSTokenizer::Scope scope(testCase);
         CSSParserTokenRange range = scope.tokenRange();
         bool passed = CSSSelectorParser::consumeANPlusB(range, ab);
         EXPECT_FALSE(passed);
     }
 }
 
 TEST(CSSSelectorParserTest, ShadowDomPseudoInCompound)
 {
     const char* testCases[][2] = {
         { "::shadow", "::shadow" },
         { ".a::shadow", ".a::shadow" },
         { "::content", "::content" },
         { ".a::content", ".a::content" },
-        { "::content.a", "::content.a" },
-        { "::content.a.b", "::content.a.b" },
-        { ".a::content.b", ".a::content.b" },
     };
 
-    for (unsigned i = 0; i < WTF_ARRAY_LENGTH(testCases); ++i) {
-        SCOPED_TRACE(testCases[i][0]);
-        CSSTokenizer::Scope scope(testCases[i][0]);
+    for (auto testCase : testCases) {
+        SCOPED_TRACE(testCase[0]);
+        CSSTokenizer::Scope scope(testCase[0]);
         CSSParserTokenRange range = scope.tokenRange();
         CSSSelectorList list = CSSSelectorParser::parseSelector(range, CSSParserContext(HTMLStandardMode, nullptr), nullptr);
-        EXPECT_STREQ(testCases[i][1], list.selectorsText().ascii().data());
+        EXPECT_STREQ(testCase[1], list.selectorsText().ascii().data());
     }
 }
 
 TEST(CSSSelectorParserTest, PseudoElementsInCompoundLists)
 {
     const char* testCases[] = {
         ":not(::before)",
         ":not(::content)",
         ":not(::shadow)",
         ":host(::before)",
         ":host(::content)",
         ":host(::shadow)",
         ":host-context(::before)",
         ":host-context(::content)",
         ":host-context(::shadow)",
         ":-webkit-any(::after, ::before)",
         ":-webkit-any(::content, span)",
         ":-webkit-any(div, ::shadow)"
     };
 
     for (auto testCase : testCases) {
         CSSTokenizer::Scope scope(testCase);
         CSSParserTokenRange range = scope.tokenRange();
         CSSSelectorList list = CSSSelectorParser::parseSelector(range, CSSParserContext(HTMLStandardMode, nullptr), nullptr);
         EXPECT_FALSE(list.isValid());
     }
 }
 
+TEST(CSSSelectorParserTest, ValidSimpleAfterPseudoElementInCompound)
+{
+    const char* testCases[] = {
+        "::-webkit-volume-slider:hover",
+        "::selection:window-inactive",
+        "::-webkit-scrollbar:disabled",
+        "::-webkit-volume-slider:not(:hover)"
+    };
+
+    for (auto testCase : testCases) {
+        CSSTokenizer::Scope scope(testCase);
+        CSSParserTokenRange range = scope.tokenRange();
+        CSSSelectorList list = CSSSelectorParser::parseSelector(range, CSSParserContext(HTMLStandardMode, nullptr), nullptr);
+        EXPECT_TRUE(list.isValid());
+    }
+}
+
+TEST(CSSSelectorParserTest, InvalidSimpleAfterPseudoElementInCompound)
+{
+    const char* testCases[] = {
+        "::before#id",
+        "::after:hover",
+        ".class::content::before",
+        "::shadow.class",
+        "::selection:window-inactive::before",
+        "::-webkit-volume-slider.class",
+        "::content.a",
+        "::content.a.b",
+        ".a::content.b"
+    };

[Timothy Loh, 2016/01/15 04:22:57]

Can we also add some tests with :not here?

+
+    for (auto testCase : testCases) {
+        CSSTokenizer::Scope scope(testCase);
+        CSSParserTokenRange range = scope.tokenRange();
+        CSSSelectorList list = CSSSelectorParser::parseSelector(range, CSSParserContext(HTMLStandardMode, nullptr), nullptr);
+        EXPECT_FALSE(list.isValid());
+    }
+}
+
 } // namespace