Make CSSParserContext be garbage collected.

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 "core/css/CSSCustomIdentValue.h"
 #include "core/css/CSSCustomPropertyDeclaration.h"
 #include "core/css/CSSKeyframesRule.h"
 #include "core/css/CSSStyleSheet.h"
@@ skipping 18 matching lines @@
 #include "core/dom/Element.h"
 #include "core/frame/Deprecation.h"
 #include "core/frame/UseCounter.h"
 #include "platform/instrumentation/tracing/TraceEvent.h"
 #include "wtf/PtrUtil.h"
 #include <bitset>
 #include <memory>
 
 namespace blink {
 
-CSSParserImpl::CSSParserImpl(const CSSParserContext& context,
+CSSParserImpl::CSSParserImpl(const CSSParserContext* context,
                              StyleSheetContents* styleSheet)
     : m_context(context),
       m_styleSheet(styleSheet),
       m_observerWrapper(nullptr) {}
 
 MutableStylePropertySet::SetResult CSSParserImpl::parseValue(
     MutableStylePropertySet* declaration,
     CSSPropertyID unresolvedProperty,
     const String& string,
     bool important,
-    const CSSParserContext& context) {
+    const CSSParserContext* context) {
   CSSParserImpl parser(context);
   StyleRule::RuleType ruleType = StyleRule::Style;
   if (declaration->cssParserMode() == CSSViewportRuleMode)
     ruleType = StyleRule::Viewport;
   else if (declaration->cssParserMode() == CSSFontFaceRuleMode)
     ruleType = StyleRule::FontFace;
   CSSTokenizer tokenizer(string);
   parser.consumeDeclarationValue(tokenizer.tokenRange(), unresolvedProperty,
                                  important, ruleType);
   bool didParse = false;
   bool didChange = false;
   if (!parser.m_parsedProperties.isEmpty()) {
     didParse = true;
     didChange = declaration->addParsedProperties(parser.m_parsedProperties);
   }
   return MutableStylePropertySet::SetResult{didParse, didChange};
 }
 
 MutableStylePropertySet::SetResult CSSParserImpl::parseVariableValue(
     MutableStylePropertySet* declaration,
     const AtomicString& propertyName,
     const PropertyRegistry* registry,
     const String& value,
     bool important,
-    const CSSParserContext& context,
+    const CSSParserContext* context,
     bool isAnimationTainted) {
   CSSParserImpl parser(context);
   CSSTokenizer tokenizer(value);
   parser.consumeVariableValue(tokenizer.tokenRange(), propertyName, important,
                               isAnimationTainted);
   bool didParse = false;
   bool didChange = false;
   if (!parser.m_parsedProperties.isEmpty()) {
     if (registry) {
       const PropertyRegistry::Registration* registration =
@@ skipping 60 matching lines @@
   ImmutableStylePropertySet* result = ImmutableStylePropertySet::create(
       results.data() + unusedEntries, results.size() - unusedEntries, mode);
   parsedProperties.clear();
   return result;
 }
 
 ImmutableStylePropertySet* CSSParserImpl::parseInlineStyleDeclaration(
     const String& string,
     Element* element) {
   Document& document = element->document();
-  CSSParserContext context =
-      CSSParserContext(document.elementSheet().contents()->parserContext(),
-                       UseCounter::getFrom(&document));
+  CSSParserContext* context =
+      new CSSParserContext(document.elementSheet().contents()->parserContext(),
+                           UseCounter::getFrom(&document));
   CSSParserMode mode = element->isHTMLElement() && !document.inQuirksMode()
                            ? HTMLStandardMode
                            : HTMLQuirksMode;
-  context.setMode(mode);
+  context->setMode(mode);
   CSSParserImpl parser(context, document.elementSheet().contents());
   CSSTokenizer tokenizer(string);
   parser.consumeDeclarationList(tokenizer.tokenRange(), StyleRule::Style);
   return createStylePropertySet(parser.m_parsedProperties, mode);
 }
 
 bool CSSParserImpl::parseDeclarationList(MutableStylePropertySet* declaration,
                                          const String& string,
-                                         const CSSParserContext& context) {
+                                         const CSSParserContext* context) {
   CSSParserImpl parser(context);
   StyleRule::RuleType ruleType = StyleRule::Style;
   if (declaration->cssParserMode() == CSSViewportRuleMode)
     ruleType = StyleRule::Viewport;
   CSSTokenizer tokenizer(string);
   parser.consumeDeclarationList(tokenizer.tokenRange(), ruleType);
   if (parser.m_parsedProperties.isEmpty())
     return false;
 
   std::bitset<numCSSProperties> seenProperties;
   size_t unusedEntries = parser.m_parsedProperties.size();
   HeapVector<CSSProperty, 256> results(unusedEntries);
   HashSet<AtomicString> seenCustomProperties;
   filterProperties(true, parser.m_parsedProperties, results, unusedEntries,
                    seenProperties, seenCustomProperties);
   filterProperties(false, parser.m_parsedProperties, results, unusedEntries,
                    seenProperties, seenCustomProperties);
   if (unusedEntries)
     results.remove(0, unusedEntries);
   return declaration->addParsedProperties(results);
 }
 
 StyleRuleBase* CSSParserImpl::parseRule(const String& string,
-                                        const CSSParserContext& context,
+                                        const CSSParserContext* context,
                                         StyleSheetContents* styleSheet,
                                         AllowedRulesType allowedRules) {
   CSSParserImpl parser(context, styleSheet);
   CSSTokenizer tokenizer(string);
   CSSParserTokenRange range = tokenizer.tokenRange();
   range.consumeWhitespace();
   if (range.atEnd())
     return nullptr;  // Parse error, empty rule
   StyleRuleBase* rule;
   if (range.peek().type() == AtKeywordToken)
     rule = parser.consumeAtRule(range, allowedRules);
   else
     rule = parser.consumeQualifiedRule(range, allowedRules);
   if (!rule)
     return nullptr;  // Parse error, failed to consume rule
   range.consumeWhitespace();
   if (!rule || !range.atEnd())
     return nullptr;  // Parse error, trailing garbage
   return rule;
 }
 
 void CSSParserImpl::parseStyleSheet(const String& string,
-                                    const CSSParserContext& context,
+                                    const CSSParserContext* context,
                                     StyleSheetContents* styleSheet,
                                     bool deferPropertyParsing) {
   TRACE_EVENT_BEGIN2("blink,blink_style", "CSSParserImpl::parseStyleSheet",
-                     "baseUrl", context.baseURL().getString().utf8(), "mode",
-                     context.mode());
+                     "baseUrl", context->baseURL().getString().utf8(), "mode",
+                     context->mode());
 
   TRACE_EVENT_BEGIN0("blink,blink_style",
                      "CSSParserImpl::parseStyleSheet.tokenize");
   CSSTokenizer tokenizer(string);
   TRACE_EVENT_END0("blink,blink_style",
                    "CSSParserImpl::parseStyleSheet.tokenize");
 
   TRACE_EVENT_BEGIN0("blink,blink_style",
                      "CSSParserImpl::parseStyleSheet.parse");
   CSSParserImpl parser(context, styleSheet);
@@ skipping 93 matching lines @@
 bool CSSParserImpl::supportsDeclaration(CSSParserTokenRange& range) {
   ASSERT(m_parsedProperties.isEmpty());
   consumeDeclaration(range, StyleRule::Style);
   bool result = !m_parsedProperties.isEmpty();
   m_parsedProperties.clear();
   return result;
 }
 
 void CSSParserImpl::parseDeclarationListForInspector(
     const String& declaration,
-    const CSSParserContext& context,
+    const CSSParserContext* context,
     CSSParserObserver& observer) {
   CSSParserImpl parser(context);
   CSSParserObserverWrapper wrapper(observer);
   parser.m_observerWrapper = &wrapper;
   CSSTokenizer tokenizer(declaration, wrapper);
   observer.startRuleHeader(StyleRule::Style, 0);
   observer.endRuleHeader(1);
   parser.consumeDeclarationList(tokenizer.tokenRange(), StyleRule::Style);
 }
 
 void CSSParserImpl::parseStyleSheetForInspector(const String& string,
-                                                const CSSParserContext& context,
+                                                const CSSParserContext* context,
                                                 StyleSheetContents* styleSheet,
                                                 CSSParserObserver& observer) {
   CSSParserImpl parser(context, styleSheet);
   CSSParserObserverWrapper wrapper(observer);
   parser.m_observerWrapper = &wrapper;
   CSSTokenizer tokenizer(string, wrapper);
   bool firstRuleValid =
       parser.consumeRuleList(tokenizer.tokenRange(), TopLevelRuleList,
                              [&styleSheet](StyleRuleBase* rule) {
                                if (rule->isCharsetRule())
                                  return;
                                styleSheet->parserAppendRule(rule);
                              });
   styleSheet->setHasSyntacticallyValidCSSHeader(firstRuleValid);
 }
 
 StylePropertySet* CSSParserImpl::parseDeclarationListForLazyStyle(
     CSSParserTokenRange block,
-    const CSSParserContext& context) {
+    const CSSParserContext* context) {
   CSSParserImpl parser(context);
   parser.consumeDeclarationList(std::move(block), StyleRule::Style);
-  return createStylePropertySet(parser.m_parsedProperties, context.mode());
+  return createStylePropertySet(parser.m_parsedProperties, context->mode());
 }
 
 static CSSParserImpl::AllowedRulesType computeNewAllowedRules(
     CSSParserImpl::AllowedRulesType allowedRules,
     StyleRuleBase* rule) {
   if (!rule || allowedRules == CSSParserImpl::KeyframeRules ||
       allowedRules == CSSParserImpl::NoRules)
     return allowedRules;
   ASSERT(allowedRules <= CSSParserImpl::RegularRules);
   if (rule->isCharsetRule() || rule->isImportRule())
@@ skipping 61 matching lines @@
                                             AllowedRulesType allowedRules) {
   ASSERT(range.peek().type() == AtKeywordToken);
   const StringView name = range.consumeIncludingWhitespace().value();
   const CSSParserToken* preludeStart = &range.peek();
   while (!range.atEnd() && range.peek().type() != LeftBraceToken &&
          range.peek().type() != SemicolonToken)
     range.consumeComponentValue();
 
   CSSParserTokenRange prelude = range.makeSubRange(preludeStart, &range.peek());
   CSSAtRuleID id = cssAtRuleID(name);
-  if (id != CSSAtRuleInvalid && m_context.useCounter())
-    countAtRule(m_context.useCounter(), id);
+  if (id != CSSAtRuleInvalid && m_context->isUseCounterRecordingEnabled())
+    countAtRule(m_context->useCounter(), id);
 
   if (range.atEnd() || range.peek().type() == SemicolonToken) {
     range.consume();
     if (allowedRules == AllowCharsetRules && id == CSSAtRuleCharset)
       return consumeCharsetRule(prelude);
     if (allowedRules <= AllowImportRules && id == CSSAtRuleImport)
       return consumeImportRule(prelude);
     if (allowedRules <= AllowNamespaceRules && id == CSSAtRuleNamespace)
       return consumeNamespaceRule(prelude);
     if (allowedRules == ApplyRules && id == CSSAtRuleApply) {
@@ skipping 167 matching lines @@
 
   return StyleRuleSupports::create(prelude.serialize().stripWhiteSpace(),
                                    supported, rules);
 }
 
 StyleRuleViewport* CSSParserImpl::consumeViewportRule(
     CSSParserTokenRange prelude,
     CSSParserTokenRange block) {
   // Allow @viewport rules from UA stylesheets even if the feature is disabled.
   if (!RuntimeEnabledFeatures::cssViewportEnabled() &&
-      !isUASheetBehavior(m_context.mode()))
+      !isUASheetBehavior(m_context->mode()))
     return nullptr;
 
   if (!prelude.atEnd())
     return nullptr;  // Parser error; @viewport prelude should be empty
 
   if (m_observerWrapper) {
     unsigned endOffset = m_observerWrapper->endOffset(prelude);
     m_observerWrapper->observer().startRuleHeader(
         StyleRule::Viewport, m_observerWrapper->startOffset(prelude));
     m_observerWrapper->observer().endRuleHeader(endOffset);
@@ skipping 39 matching lines @@
   CSSParserTokenRange rangeCopy = prelude;  // For inspector callbacks
   const CSSParserToken& nameToken = prelude.consumeIncludingWhitespace();
   if (!prelude.atEnd())
     return nullptr;  // Parse error; expected single non-whitespace token in
                      // @keyframes header
 
   String name;
   if (nameToken.type() == IdentToken) {
     name = nameToken.value().toString();
   } else if (nameToken.type() == StringToken && webkitPrefixed) {
-    if (m_context.useCounter())
-      m_context.useCounter()->count(UseCounter::QuotedKeyframesRule);
+    if (m_context->isUseCounterRecordingEnabled())
+      m_context->useCounter()->count(UseCounter::QuotedKeyframesRule);
     name = nameToken.value().toString();
   } else {
     return nullptr;  // Parse error; expected ident token in @keyframes header
   }
 
   if (m_observerWrapper) {
     m_observerWrapper->observer().startRuleHeader(
         StyleRule::Keyframes, m_observerWrapper->startOffset(rangeCopy));
     m_observerWrapper->observer().endRuleHeader(
         m_observerWrapper->endOffset(prelude));
@@ skipping 23 matching lines @@
     unsigned endOffset = m_observerWrapper->endOffset(prelude);
     m_observerWrapper->observer().startRuleHeader(
         StyleRule::Page, m_observerWrapper->startOffset(prelude));
     m_observerWrapper->observer().endRuleHeader(endOffset);
   }
 
   consumeDeclarationList(block, StyleRule::Style);
 
   return StyleRulePage::create(
       std::move(selectorList),
-      createStylePropertySet(m_parsedProperties, m_context.mode()));
+      createStylePropertySet(m_parsedProperties, m_context->mode()));
 }
 
 void CSSParserImpl::consumeApplyRule(CSSParserTokenRange prelude) {
   ASSERT(RuntimeEnabledFeatures::cssApplyAtRulesEnabled());
 
   const CSSParserToken& ident = prelude.consumeIncludingWhitespace();
   if (!prelude.atEnd() || !CSSVariableParser::isValidVariableName(ident))
     return;  // Parse error, expected a single custom property name
   m_parsedProperties.push_back(CSSProperty(
       CSSPropertyApplyAtRule,
@@ skipping 10 matching lines @@
   if (m_observerWrapper) {
     m_observerWrapper->observer().startRuleHeader(
         StyleRule::Keyframe, m_observerWrapper->startOffset(prelude));
     m_observerWrapper->observer().endRuleHeader(
         m_observerWrapper->endOffset(prelude));
   }
 
   consumeDeclarationList(block, StyleRule::Keyframe);
   return StyleRuleKeyframe::create(
       std::move(keyList),
-      createStylePropertySet(m_parsedProperties, m_context.mode()));
+      createStylePropertySet(m_parsedProperties, m_context->mode()));
 }
 
 static void observeSelectors(CSSParserObserverWrapper& wrapper,
                              CSSParserTokenRange selectors) {
   // This is easier than hooking into the CSSSelectorParser
   selectors.consumeWhitespace();
   CSSParserTokenRange originalRange = selectors;
   wrapper.observer().startRuleHeader(StyleRule::Style,
                                      wrapper.startOffset(originalRange));
 
@@ skipping 25 matching lines @@
   } else if (m_lazyState &&
              m_lazyState->shouldLazilyParseProperties(selectorList, block)) {
     DCHECK(m_styleSheet);
     return StyleRule::createLazy(std::move(selectorList),
                                  m_lazyState->createLazyParser(block));
   }
   consumeDeclarationList(block, StyleRule::Style);
 
   return StyleRule::create(
       std::move(selectorList),
-      createStylePropertySet(m_parsedProperties, m_context.mode()));
+      createStylePropertySet(m_parsedProperties, m_context->mode()));
 }
 
 void CSSParserImpl::consumeDeclarationList(CSSParserTokenRange range,
                                            StyleRule::RuleType ruleType) {
   ASSERT(m_parsedProperties.isEmpty());
 
   bool useObserver = m_observerWrapper && (ruleType == StyleRule::Style ||
                                            ruleType == StyleRule::Keyframe);
   if (useObserver) {
     m_observerWrapper->observer().startRuleBody(
@@ skipping 142 matching lines @@
     else
       return nullptr;  // Parser error, invalid value in keyframe selector
     if (range.atEnd())
       return result;
     if (range.consume().type() != CommaToken)
       return nullptr;  // Parser error
   }
 }
 
 }  // namespace blink