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

third_party/WebKit/Source/core/css/parser/CSSParserImpl.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/CSSParserImpl.h"
 
 #include <bitset>
 #include <memory>
 #include "core/css/CSSCustomIdentValue.h"
 #include "core/css/CSSCustomPropertyDeclaration.h"
@@ skipping 236 matching lines @@
   if (parser.lazy_state_)
     parser.lazy_state_->FinishInitialParsing();
   TRACE_EVENT_END0("blink,blink_style", "CSSParserImpl::parseStyleSheet.parse");
 
   TRACE_EVENT_END2("blink,blink_style", "CSSParserImpl::parseStyleSheet",
                    "tokenCount", tokenizer.TokenCount(), "length",
                    string.length());
 }
 
 CSSSelectorList CSSParserImpl::ParsePageSelector(
+    const CSSParserContext& context,
     CSSParserTokenRange range,
     StyleSheetContents* style_sheet) {
   // We only support a small subset of the css-page spec.
   range.ConsumeWhitespace();
   AtomicString type_selector;
   if (range.Peek().GetType() == kIdentToken)
     type_selector = range.Consume().Value().ToAtomicString();
 
   AtomicString pseudo;
   if (range.Peek().GetType() == kColonToken) {
     range.Consume();
     if (range.Peek().GetType() != kIdentToken)
       return CSSSelectorList();
     pseudo = range.Consume().Value().ToAtomicString();
   }
 
   range.ConsumeWhitespace();
   if (!range.AtEnd())
     return CSSSelectorList();  // Parse error; extra tokens in @page selector
 
   std::unique_ptr<CSSParserSelector> selector;
   if (!type_selector.IsNull() && pseudo.IsNull()) {
     selector = CSSParserSelector::Create(QualifiedName(
         g_null_atom, type_selector, style_sheet->DefaultNamespace()));
   } else {
     selector = CSSParserSelector::Create();
     if (!pseudo.IsNull()) {
       selector->SetMatch(CSSSelector::kPagePseudoClass);
-      selector->UpdatePseudoType(pseudo.DeprecatedLower());
+      selector->UpdatePseudoType(pseudo.DeprecatedLower(), context);
       if (selector->GetPseudoType() == CSSSelector::kPseudoUnknown)
         return CSSSelectorList();
     }
     if (!type_selector.IsNull()) {
       selector->PrependTagSelector(QualifiedName(
           g_null_atom, type_selector, style_sheet->DefaultNamespace()));
     }
   }
 
   selector->SetForPage();
@@ skipping 430 matching lines @@
       block, kKeyframesRuleList, [keyframe_rule](StyleRuleBase* keyframe) {
         keyframe_rule->ParserAppendKeyframe(ToStyleRuleKeyframe(keyframe));
       });
   keyframe_rule->SetName(name);
   keyframe_rule->SetVendorPrefixed(webkit_prefixed);
   return keyframe_rule;
 }
 
 StyleRulePage* CSSParserImpl::ConsumePageRule(CSSParserTokenRange prelude,
                                               CSSParserTokenRange block) {
-  CSSSelectorList selector_list = ParsePageSelector(prelude, style_sheet_);
+  CSSSelectorList selector_list =
+      ParsePageSelector(*context_, prelude, style_sheet_);
   if (!selector_list.IsValid())
     return nullptr;  // Parse error, invalid @page selector
 
   if (observer_wrapper_) {
     unsigned end_offset = observer_wrapper_->EndOffset(prelude);
     observer_wrapper_->Observer().StartRuleHeader(
         StyleRule::kPage, observer_wrapper_->StartOffset(prelude));
     observer_wrapper_->Observer().EndRuleHeader(end_offset);
   }
 
@@ skipping 237 matching lines @@
     else
       return nullptr;  // Parser error, invalid value in keyframe selector
     if (range.AtEnd())
       return result;
     if (range.Consume().GetType() != kCommaToken)
       return nullptr;  // Parser error
   }
 }
 
 }  // namespace blink