Make /deep/ as no-op and remove ::shadow in dynamic profile

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

 // Copyright 2014 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 <memory>
 #include "core/css/CSSSelectorList.h"
 #include "core/css/StyleSheetContents.h"
 #include "core/css/parser/CSSParserContext.h"
@@ skipping 424 matching lines @@
   const CSSParserToken& token = range.Peek();
   if (token.GetType() != kIdentToken && token.GetType() != kFunctionToken)
     return nullptr;
 
   std::unique_ptr<CSSParserSelector> selector = CSSParserSelector::Create();
   selector->SetMatch(colons == 1 ? CSSSelector::kPseudoClass
                                  : CSSSelector::kPseudoElement);
 
   AtomicString value = token.Value().ToAtomicString().LowerASCII();
   bool has_arguments = token.GetType() == kFunctionToken;
-  selector->UpdatePseudoType(value, has_arguments);
+  selector->UpdatePseudoType(value, *context_, has_arguments);
 
   if (!RuntimeEnabledFeatures::cssSelectorsFocusWithinEnabled() &&
       selector->GetPseudoType() == CSSSelector::kPseudoFocusWithin)
     return nullptr;
 
   if (selector->Match() == CSSSelector::kPseudoElement &&
       disallow_pseudo_elements_)
     return nullptr;
 
   if (token.GetType() == kIdentToken) {
@@ skipping 119 matching lines @@
     case '/': {
       // Match /deep/
       range.Consume();
       const CSSParserToken& ident = range.Consume();
       if (ident.GetType() != kIdentToken ||
           !EqualIgnoringASCIICase(ident.Value(), "deep"))
         failed_parsing_ = true;
       const CSSParserToken& slash = range.ConsumeIncludingWhitespace();
       if (slash.GetType() != kDelimiterToken || slash.Delimiter() != '/')
         failed_parsing_ = true;
-      return CSSSelector::kShadowDeep;
+      return context_->IsDynamicProfile() ? CSSSelector::kShadowDeepAsDescendant
+                                          : CSSSelector::kShadowDeep;
     }
 
     default:
       break;
   }
   return fallback_result;
 }
 
 CSSSelector::MatchType CSSSelectorParser::ConsumeAttributeMatch(
     CSSParserTokenRange& range) {
@@ skipping 208 matching lines @@
 
   while (split_after->TagHistory() &&
          !split_after->TagHistory()->NeedsImplicitShadowCombinatorForMatching())
     split_after = split_after->TagHistory();
 
   if (!split_after || !split_after->TagHistory())
     return compound_selector;
 
   std::unique_ptr<CSSParserSelector> second_compound =
       split_after->ReleaseTagHistory();
+  // TODO: Check second_compound->GetPseudoType()

[kochi, 2017/05/09 14:29:38]

What does this mean?

[hayato, 2017/05/10 06:57:04]

This was my private TODO which I forgot to remove.

[kochi, 2017/05/11 02:29:07]

Acknowledged.

   second_compound->AppendTagHistory(
       second_compound->GetPseudoType() == CSSSelector::kPseudoSlotted
           ? CSSSelector::kShadowSlot
           : CSSSelector::kShadowPseudo,
       std::move(compound_selector));
   return second_compound;
 }
 
 void CSSSelectorParser::RecordUsageAndDeprecations(
     const CSSSelectorList& selector_list) {
@@ skipping 74 matching lines @@
       }
       if (current->Relation() == CSSSelector::kIndirectAdjacent)
         context_->Count(UseCounter::kCSSSelectorIndirectAdjacent);
       if (current->SelectorList())
         RecordUsageAndDeprecations(*current->SelectorList());
     }
   }
 }
 
 }  // namespace blink