Provide a CSSParserContext to CSSSyntaxDescriptor

third_party/WebKit/Source/core/css/CSSSyntaxDescriptor.cpp

 // Copyright 2016 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/CSSSyntaxDescriptor.h"
 
 #include "core/css/CSSCustomPropertyDeclaration.h"
 #include "core/css/CSSURIValue.h"
 #include "core/css/CSSValueList.h"
 #include "core/css/CSSVariableReferenceValue.h"
-#include "core/css/parser/CSSParserContext.h"
 #include "core/css/parser/CSSParserIdioms.h"
 #include "core/css/parser/CSSPropertyParserHelpers.h"
 #include "core/css/parser/CSSVariableParser.h"
 #include "core/html/parser/HTMLParserIdioms.h"
 
 namespace blink {
 
 void consumeWhitespace(const String& string, size_t& offset) {
   while (isHTMLSpace(string[offset]))
     offset++;
@@ skipping 101 matching lines @@
     consumeWhitespace(input, offset);
     m_syntaxComponents.push_back(CSSSyntaxComponent(type, ident, repeatable));
 
   } while (consumeCharacterAndWhitespace(input, '|', offset));
 
   if (offset != input.length())
     m_syntaxComponents.clear();
 }
 
 const CSSValue* consumeSingleType(const CSSSyntaxComponent& syntax,
-                                  CSSParserTokenRange& range) {
+                                  CSSParserTokenRange& range,
+                                  const CSSParserContext* context) {
   using namespace CSSPropertyParserHelpers;
 
   switch (syntax.m_type) {
     case CSSSyntaxType::Ident:
       if (range.peek().type() == IdentToken &&
           range.peek().value() == syntax.m_string) {
         range.consumeIncludingWhitespace();
         return CSSCustomIdentValue::create(AtomicString(syntax.m_string));
       }
       return nullptr;
     case CSSSyntaxType::Length:
       return consumeLength(range, HTMLStandardMode, ValueRange::ValueRangeAll);
     case CSSSyntaxType::Number:
       return consumeNumber(range, ValueRange::ValueRangeAll);
     case CSSSyntaxType::Percentage:
       return consumePercent(range, ValueRange::ValueRangeAll);
     case CSSSyntaxType::LengthPercentage:
       return consumeLengthOrPercent(range, HTMLStandardMode,
                                     ValueRange::ValueRangeAll);
     case CSSSyntaxType::Color:
       return consumeColor(range, HTMLStandardMode);
     case CSSSyntaxType::Image:
-      // TODO(timloh): This probably needs a proper parser context for relative
-      // URL resolution.
-      return consumeImage(range, strictCSSParserContext());
+      return consumeImage(range, context);
     case CSSSyntaxType::Url:
       return consumeUrl(range);
     case CSSSyntaxType::Integer:
       return consumeInteger(range);
     case CSSSyntaxType::Angle:
       return consumeAngle(range);
     case CSSSyntaxType::Time:
       return consumeTime(range, ValueRange::ValueRangeAll);
     case CSSSyntaxType::Resolution:
       return consumeResolution(range);
     case CSSSyntaxType::TransformFunction:
       return nullptr;  // TODO(timloh): Implement this.
     case CSSSyntaxType::CustomIdent:
       return consumeCustomIdent(range);
     default:
       NOTREACHED();
       return nullptr;
   }
 }
 
 const CSSValue* consumeSyntaxComponent(const CSSSyntaxComponent& syntax,
-                                       CSSParserTokenRange range) {
+                                       CSSParserTokenRange range,
+                                       const CSSParserContext* context) {
   // CSS-wide keywords are already handled by the CSSPropertyParser
   if (syntax.m_repeatable) {
     CSSValueList* list = CSSValueList::createSpaceSeparated();
     while (!range.atEnd()) {
-      const CSSValue* value = consumeSingleType(syntax, range);
+      const CSSValue* value = consumeSingleType(syntax, range, context);
       if (!value)
         return nullptr;
       list->append(*value);
     }
     return list;
   }
-  const CSSValue* result = consumeSingleType(syntax, range);
+  const CSSValue* result = consumeSingleType(syntax, range, context);
   if (!range.atEnd())
     return nullptr;
   return result;
 }
 
 const CSSValue* CSSSyntaxDescriptor::parse(CSSParserTokenRange range,
+                                           const CSSParserContext* context,
                                            bool isAnimationTainted) const {
   if (isTokenStream()) {
     return CSSVariableParser::parseRegisteredPropertyValue(range, false,
                                                            isAnimationTainted);
   }
   range.consumeWhitespace();
   for (const CSSSyntaxComponent& component : m_syntaxComponents) {
-    if (const CSSValue* result = consumeSyntaxComponent(component, range))
+    if (const CSSValue* result =
+            consumeSyntaxComponent(component, range, context))
       return result;
   }
   return CSSVariableParser::parseRegisteredPropertyValue(range, true,
                                                          isAnimationTainted);
 }
 
 }  // namespace blink