Make CSSParserContext be garbage collected.

third_party/WebKit/Source/core/css/parser/CSSParser.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/CSSParser.h"
 
 #include "core/css/CSSColorValue.h"
 #include "core/css/CSSKeyframeRule.h"
 #include "core/css/StyleColor.h"
 #include "core/css/StyleRule.h"
 #include "core/css/StyleSheetContents.h"
 #include "core/css/parser/CSSParserFastPaths.h"
 #include "core/css/parser/CSSParserImpl.h"
 #include "core/css/parser/CSSPropertyParser.h"
 #include "core/css/parser/CSSSelectorParser.h"
 #include "core/css/parser/CSSSupportsParser.h"
 #include "core/css/parser/CSSTokenizer.h"
 #include "core/css/parser/CSSVariableParser.h"
 #include "core/layout/LayoutTheme.h"
 #include <memory>
 
 namespace blink {
 
-bool CSSParser::parseDeclarationList(const CSSParserContext& context,
+bool CSSParser::parseDeclarationList(const CSSParserContext* context,
                                      MutableStylePropertySet* propertySet,
                                      const String& declaration) {
   return CSSParserImpl::parseDeclarationList(propertySet, declaration, context);
 }
 
 void CSSParser::parseDeclarationListForInspector(
-    const CSSParserContext& context,
+    const CSSParserContext* context,
     const String& declaration,
     CSSParserObserver& observer) {
   CSSParserImpl::parseDeclarationListForInspector(declaration, context,
                                                   observer);
 }
 
-CSSSelectorList CSSParser::parseSelector(const CSSParserContext& context,
+CSSSelectorList CSSParser::parseSelector(const CSSParserContext* context,
                                          StyleSheetContents* styleSheetContents,
                                          const String& selector) {
   CSSTokenizer tokenizer(selector);
   return CSSSelectorParser::parseSelector(tokenizer.tokenRange(), context,
                                           styleSheetContents);
 }
 
 CSSSelectorList CSSParser::parsePageSelector(
-    const CSSParserContext& context,
+    const CSSParserContext* context,
     StyleSheetContents* styleSheetContents,
     const String& selector) {
   CSSTokenizer tokenizer(selector);
   return CSSParserImpl::parsePageSelector(tokenizer.tokenRange(),
                                           styleSheetContents);
 }
 
-StyleRuleBase* CSSParser::parseRule(const CSSParserContext& context,
+StyleRuleBase* CSSParser::parseRule(const CSSParserContext* context,
                                     StyleSheetContents* styleSheet,
                                     const String& rule) {
   return CSSParserImpl::parseRule(rule, context, styleSheet,
                                   CSSParserImpl::AllowImportRules);
 }
 
-void CSSParser::parseSheet(const CSSParserContext& context,
+void CSSParser::parseSheet(const CSSParserContext* context,
                            StyleSheetContents* styleSheet,
                            const String& text,
                            bool deferPropertyParsing) {
   return CSSParserImpl::parseStyleSheet(text, context, styleSheet,
                                         deferPropertyParsing);
 }
 
-void CSSParser::parseSheetForInspector(const CSSParserContext& context,
+void CSSParser::parseSheetForInspector(const CSSParserContext* context,
                                        StyleSheetContents* styleSheet,
                                        const String& text,
                                        CSSParserObserver& observer) {
   return CSSParserImpl::parseStyleSheetForInspector(text, context, styleSheet,
                                                     observer);
 }
 
 MutableStylePropertySet::SetResult CSSParser::parseValue(
     MutableStylePropertySet* declaration,
     CSSPropertyID unresolvedProperty,
     const String& string,
+    bool important) {
+  return parseValue(declaration, unresolvedProperty, string, important,
+                    static_cast<StyleSheetContents*>(nullptr));

[haraken, 2017/01/12 04:51:13]

What is this change for?

[Bret, 2017/01/13 02:15:28]

There were some calls that were trying to pass in 0/nullptr for
StyleSheetContents*, but since I made the version that takes a CSSParserContext
into a pointer it became ambiguous. I decided to add this overload to handle it,
but if you think it's too much I can move the
static_cast<StyleSheetContents*>(nullptr) to the callsites instead.

+}
+
+MutableStylePropertySet::SetResult CSSParser::parseValue(
+    MutableStylePropertySet* declaration,
+    CSSPropertyID unresolvedProperty,
+    const String& string,
     bool important,
     StyleSheetContents* styleSheet) {
   if (string.isEmpty()) {
     bool didParse = false;
     bool didChange = false;
     return MutableStylePropertySet::SetResult{didParse, didChange};
   }
 
   CSSPropertyID resolvedProperty = resolveCSSPropertyID(unresolvedProperty);
   CSSParserMode parserMode = declaration->cssParserMode();
   CSSValue* value =
       CSSParserFastPaths::maybeParseValue(resolvedProperty, string, parserMode);
   if (value) {
     bool didParse = true;
     bool didChange = declaration->setProperty(
         CSSProperty(resolvedProperty, *value, important));
     return MutableStylePropertySet::SetResult{didParse, didChange};
   }
-  CSSParserContext context(parserMode, nullptr);
+  CSSParserContext* context;
   if (styleSheet) {
-    context = styleSheet->parserContext();
-    context.setMode(parserMode);
+    context = new CSSParserContext(styleSheet->parserContext(), nullptr);
+    context->setMode(parserMode);
+  } else {
+    context = new CSSParserContext(parserMode);
   }
   return parseValue(declaration, unresolvedProperty, string, important,
                     context);
 }
 
 MutableStylePropertySet::SetResult CSSParser::parseValueForCustomProperty(
     MutableStylePropertySet* declaration,
     const AtomicString& propertyName,
     const PropertyRegistry* registry,
     const String& value,
     bool important,
     StyleSheetContents* styleSheet,
     bool isAnimationTainted) {
   DCHECK(CSSVariableParser::isValidVariableName(propertyName));
   if (value.isEmpty()) {
     bool didParse = false;
     bool didChange = false;
     return MutableStylePropertySet::SetResult{didParse, didChange};
   }
   CSSParserMode parserMode = declaration->cssParserMode();
-  CSSParserContext context(parserMode, nullptr);
+  CSSParserContext* context;
   if (styleSheet) {
-    context = styleSheet->parserContext();
-    context.setMode(parserMode);
+    context = new CSSParserContext(styleSheet->parserContext(), nullptr);
+    context->setMode(parserMode);
+  } else {
+    context = new CSSParserContext(parserMode);
   }
   return CSSParserImpl::parseVariableValue(declaration, propertyName, registry,
                                            value, important, context,
                                            isAnimationTainted);
 }
 
 ImmutableStylePropertySet* CSSParser::parseCustomPropertySet(
     CSSParserTokenRange range) {
   return CSSParserImpl::parseCustomPropertySet(range);
 }
 
 MutableStylePropertySet::SetResult CSSParser::parseValue(
     MutableStylePropertySet* declaration,
     CSSPropertyID unresolvedProperty,
     const String& string,
     bool important,
-    const CSSParserContext& context) {
+    const CSSParserContext* context) {
   return CSSParserImpl::parseValue(declaration, unresolvedProperty, string,
                                    important, context);
 }
 
 const CSSValue* CSSParser::parseSingleValue(CSSPropertyID propertyID,
                                             const String& string,
-                                            const CSSParserContext& context) {
+                                            const CSSParserContext* context) {
   if (string.isEmpty())
     return nullptr;
   if (CSSValue* value = CSSParserFastPaths::maybeParseValue(propertyID, string,
-                                                            context.mode()))
+                                                            context->mode()))
     return value;
   CSSTokenizer tokenizer(string);
   return CSSPropertyParser::parseSingleValue(propertyID, tokenizer.tokenRange(),
                                              context);
 }
 
 ImmutableStylePropertySet* CSSParser::parseInlineStyleDeclaration(
     const String& styleString,
     Element* element) {
   return CSSParserImpl::parseInlineStyleDeclaration(styleString, element);
 }
 
 std::unique_ptr<Vector<double>> CSSParser::parseKeyframeKeyList(
     const String& keyList) {
   return CSSParserImpl::parseKeyframeKeyList(keyList);
 }
 
-StyleRuleKeyframe* CSSParser::parseKeyframeRule(const CSSParserContext& context,
+StyleRuleKeyframe* CSSParser::parseKeyframeRule(const CSSParserContext* context,
                                                 const String& rule) {
   StyleRuleBase* keyframe = CSSParserImpl::parseRule(
       rule, context, nullptr, CSSParserImpl::KeyframeRules);
   return toStyleRuleKeyframe(keyframe);
 }
 
 bool CSSParser::parseSupportsCondition(const String& condition) {
   CSSTokenizer tokenizer(condition);
   CSSParserImpl parser(strictCSSParserContext());
   return CSSSupportsParser::supportsCondition(tokenizer.tokenRange(), parser) ==
@@ skipping 30 matching lines @@
   if (!StyleColor::isSystemColor(id))
     return false;
 
   color = LayoutTheme::theme().systemColor(id);
   return true;
 }
 
 const CSSValue* CSSParser::parseFontFaceDescriptor(
     CSSPropertyID propertyID,
     const String& propertyValue,
-    const CSSParserContext& context) {
+    const CSSParserContext* context) {
   StringBuilder builder;
   builder.append("@font-face { ");
   builder.append(getPropertyNameString(propertyID));
   builder.append(" : ");
   builder.append(propertyValue);
   builder.append("; }");
   StyleRuleBase* rule = parseRule(context, nullptr, builder.toString());
   if (!rule || !rule->isFontFaceRule())
     return nullptr;
   return toStyleRuleFontFace(rule)->properties().getPropertyCSSValue(
       propertyID);
 }
 
 }  // namespace blink