Update CSSSelectorParserTest so that it doesn't test /deep/ nor ::shadow

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/StyleSheetContents.h"
 #include "core/css/parser/CSSParserContext.h"
 #include "core/css/parser/CSSTokenizer.h"
@@ skipping 87 matching lines @@
 
     std::pair<int, int> ab;
     CSSTokenizer tokenizer(test_case);
     CSSParserTokenRange range = tokenizer.TokenRange();
     bool passed = CSSSelectorParser::ConsumeANPlusB(range, ab);
     EXPECT_FALSE(passed);
   }
 }
 
 TEST(CSSSelectorParserTest, ShadowDomPseudoInCompound) {
-  const char* test_cases[][2] = {{"::shadow", "::shadow"},
-                                 {".a::shadow", ".a::shadow"},
-                                 {"::content", "::content"},
+  const char* test_cases[][2] = {{"::content", "::content"},
                                  {".a::content", ".a::content"},
                                  {"::content.a", "::content.a"},
                                  {"::content.a.b", "::content.a.b"},
                                  {".a::content.b", ".a::content.b"},
                                  {"::content:not(#id)", "::content:not(#id)"}};
 
   for (auto test_case : test_cases) {
     SCOPED_TRACE(test_case[0]);
     CSSTokenizer tokenizer(test_case[0]);
     CSSParserTokenRange range = tokenizer.TokenRange();
     CSSSelectorList list = CSSSelectorParser::ParseSelector(
         range, CSSParserContext::Create(kHTMLStandardMode), nullptr);
     EXPECT_STREQ(test_case[1], list.SelectorsText().Ascii().data());
   }
 }
 
 TEST(CSSSelectorParserTest, PseudoElementsInCompoundLists) {
   const char* test_cases[] = {":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)"};
+                              ":-webkit-any(::content, span)"};
 
   for (auto test_case : test_cases) {
     CSSTokenizer tokenizer(test_case);
     CSSParserTokenRange range = tokenizer.TokenRange();
     CSSSelectorList list = CSSSelectorParser::ParseSelector(
         range, CSSParserContext::Create(kHTMLStandardMode), nullptr);
     EXPECT_FALSE(list.IsValid());
   }
 }
 
@@ skipping 44 matching lines @@
   for (auto test_case : test_cases) {
     CSSTokenizer tokenizer(test_case);
     CSSParserTokenRange range = tokenizer.TokenRange();
     CSSSelectorList list = CSSSelectorParser::ParseSelector(
         range, CSSParserContext::Create(kUASheetMode), nullptr);
     EXPECT_TRUE(list.IsValid());
   }
 }
 
 TEST(CSSSelectorParserTest, ValidPseudoElementInNonRightmostCompound) {
-  const char* test_cases[] = {"::content *", "::shadow *",
-                              "::content div::before",
-                              "::shadow ::first-letter"};
+  const char* test_cases[] = {"::content *", "::content div::before"};
 
   for (auto test_case : test_cases) {
     CSSTokenizer tokenizer(test_case);
     CSSParserTokenRange range = tokenizer.TokenRange();
     CSSSelectorList list = CSSSelectorParser::ParseSelector(
         range, CSSParserContext::Create(kHTMLStandardMode), nullptr);
     EXPECT_TRUE(list.IsValid());
   }
 }
 
@@ skipping 23 matching lines @@
     CSSSelectorList list =
         CSSSelectorParser::ParseSelector(range, context, sheet);
     EXPECT_FALSE(list.IsValid());
   }
 }
 
 TEST(CSSSelectorParserTest, SerializedUniversal) {
   const char* test_cases[][2] = {
       {"*::-webkit-volume-slider", "::-webkit-volume-slider"},
       {"*::cue(i)", "::cue(i)"},
-      {"*::shadow", "::shadow"},
       {"*:host-context(.x)", "*:host-context(.x)"},
       {"*:host", "*:host"},
       {"|*::-webkit-volume-slider", "|*::-webkit-volume-slider"},
       {"|*::cue(i)", "|*::cue(i)"},
-      {"|*::shadow", "|*::shadow"},
       {"*|*::-webkit-volume-slider", "::-webkit-volume-slider"},
       {"*|*::cue(i)", "::cue(i)"},
-      {"*|*::shadow", "::shadow"},
       {"ns|*::-webkit-volume-slider", "ns|*::-webkit-volume-slider"},
-      {"ns|*::cue(i)", "ns|*::cue(i)"},
-      {"ns|*::shadow", "ns|*::shadow"}};
+      {"ns|*::cue(i)", "ns|*::cue(i)"}};
 
   CSSParserContext* context = CSSParserContext::Create(kHTMLStandardMode);
   StyleSheetContents* sheet = StyleSheetContents::Create(context);
   sheet->ParserAddNamespace("ns", "http://ns.org");
 
   for (auto test_case : test_cases) {
     SCOPED_TRACE(test_case[0]);
     CSSTokenizer tokenizer(test_case[0]);
     CSSParserTokenRange range = tokenizer.TokenRange();
     CSSSelectorList list =
@@ skipping 69 matching lines @@
     SCOPED_TRACE(test_case);
     CSSTokenizer tokenizer(test_case);
     CSSParserTokenRange range = tokenizer.TokenRange();
     CSSSelectorList list =
         CSSSelectorParser::ParseSelector(range, context, sheet);
     EXPECT_FALSE(list.IsValid());
   }
 }
 
 }  // namespace blink