Ensure original parser context is used when parsing resolved var() references

third_party/WebKit/Source/core/css/resolver/CSSVariableResolver.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/resolver/CSSVariableResolver.h"
 
 #include "core/CSSPropertyNames.h"
 #include "core/CSSValueKeywords.h"
 #include "core/StyleBuilderFunctions.h"
 #include "core/StylePropertyShorthand.h"
@@ skipping 211 matching lines @@
     const CSSVariableReferenceValue& value,
     bool disallow_animation_tainted) {
   CSSVariableResolver resolver(state);
   Vector<CSSParserToken> tokens;
   bool is_animation_tainted = false;
   if (!resolver.ResolveTokenRange(value.VariableDataValue()->Tokens(),
                                   disallow_animation_tainted, tokens,
                                   is_animation_tainted))
     return CSSUnsetValue::Create();
   const CSSValue* result =
-      CSSPropertyParser::ParseSingleValue(id, tokens, StrictCSSParserContext());
+      CSSPropertyParser::ParseSingleValue(id, tokens, value.ParserContext());
   if (!result)
     return CSSUnsetValue::Create();
   return result;
 }
 
 const CSSValue* CSSVariableResolver::ResolvePendingSubstitutions(
     const StyleResolverState& state,
     CSSPropertyID id,
     const CSSPendingSubstitutionValue& pending_value,
     bool disallow_animation_tainted) {
   // Longhands from shorthand references follow this path.
   HeapHashMap<CSSPropertyID, Member<const CSSValue>>& property_cache =
       state.ParsedPropertiesForPendingSubstitutionCache(pending_value);
 
   const CSSValue* value = property_cache.at(id);
   if (!value) {
     // TODO(timloh): We shouldn't retry this for all longhands if the shorthand
     // ends up invalid.
     CSSVariableReferenceValue* shorthand_value = pending_value.ShorthandValue();
     CSSPropertyID shorthand_property_id = pending_value.ShorthandPropertyId();
 
     CSSVariableResolver resolver(state);
 
     Vector<CSSParserToken> tokens;
     bool is_animation_tainted = false;
     if (resolver.ResolveTokenRange(
             shorthand_value->VariableDataValue()->Tokens(),
             disallow_animation_tainted, tokens, is_animation_tainted)) {
-      CSSParserContext* context = CSSParserContext::Create(kHTMLStandardMode);
 
       HeapVector<CSSProperty, 256> parsed_properties;
 
       if (CSSPropertyParser::ParseValue(
               shorthand_property_id, false, CSSParserTokenRange(tokens),
-              context, parsed_properties, StyleRule::RuleType::kStyle)) {
+              shorthand_value->ParserContext(), parsed_properties,
+              StyleRule::RuleType::kStyle)) {
         unsigned parsed_properties_count = parsed_properties.size();
         for (unsigned i = 0; i < parsed_properties_count; ++i) {
           property_cache.Set(parsed_properties[i].Id(),
                              parsed_properties[i].Value());
         }
       }
     }
     value = property_cache.at(id);
   }
 
@@ skipping 56 matching lines @@
     }
   }
 }
 
 CSSVariableResolver::CSSVariableResolver(const StyleResolverState& state)
     : inherited_variables_(state.Style()->InheritedVariables()),
       non_inherited_variables_(state.Style()->NonInheritedVariables()),
       registry_(state.GetDocument().GetPropertyRegistry()) {}
 
 }  // namespace blink