Make createCSSImageValueWithReferrer static

third_party/WebKit/Source/core/css/parser/CSSPropertyParser.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 "config.h"
 #include "core/css/parser/CSSPropertyParser.h"
 
 #include "core/StylePropertyShorthand.h"
 #include "core/css/CSSCalculationValue.h"
 #include "core/css/CSSCursorImageValue.h"
@@ skipping 2159 matching lines @@
 }
 
 static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> consumeBaselineShift(CSSParserTokenRange& range)
 {
     CSSValueID id = range.peek().id();
     if (id == CSSValueBaseline || id == CSSValueSub || id == CSSValueSuper)
         return consumeIdent(range);
     return consumeLengthOrPercent(range, SVGAttributeMode, ValueRangeAll, UnitlessQuirk::Forbid);
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::consumeImageSet(CSSParserTokenRange& range)
+static PassRefPtrWillBeRawPtr<CSSValue> consumeImageSet(CSSParserTokenRange& range, CSSParserContext context)
 {
     CSSParserTokenRange rangeCopy = range;
     CSSParserTokenRange args = consumeFunction(rangeCopy);
     RefPtrWillBeRawPtr<CSSImageSetValue> imageSet = CSSImageSetValue::create();
     do {
         AtomicString urlValue(consumeUrl(args));
         if (urlValue.isNull())
             return nullptr;
 
-        RefPtrWillBeRawPtr<CSSValue> image = createCSSImageValueWithReferrer(urlValue, completeURL(urlValue));
+        RefPtrWillBeRawPtr<CSSValue> image = CSSPropertyParser::createCSSImageValueWithReferrer(urlValue, context);
         imageSet->append(image);
 
         const CSSParserToken& token = args.consumeIncludingWhitespace();
         if (token.type() != DimensionToken)
             return nullptr;
         if (String(token.value()) != "x")
             return nullptr;
         ASSERT(token.unitType() == CSSPrimitiveValue::UnitType::Unknown);
         double imageScaleFactor = token.numericValue();
         if (imageScaleFactor <= 0)
             return nullptr;
         imageSet->append(cssValuePool().createValue(imageScaleFactor, CSSPrimitiveValue::UnitType::Number));
     } while (consumeCommaIncludingWhitespace(args));
     if (!args.atEnd())
         return nullptr;
     range = rangeCopy;
     return imageSet.release();
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::consumeCursor(CSSParserTokenRange& range)
+static PassRefPtrWillBeRawPtr<CSSValue> consumeCursor(CSSParserTokenRange& range, CSSParserContext context, bool inQuirksMode)
 {
     RefPtrWillBeRawPtr<CSSValueList> list = nullptr;
     while (!range.atEnd()) {
         RefPtrWillBeRawPtr<CSSValue> image = nullptr;
         AtomicString uri(consumeUrl(range));
         if (!uri.isNull()) {
-            image = createCSSImageValueWithReferrer(uri, completeURL(uri));
+            image = CSSPropertyParser::createCSSImageValueWithReferrer(uri, context);
         } else if (range.peek().type() == FunctionToken && range.peek().functionId() == CSSValueWebkitImageSet) {
-            image = consumeImageSet(range);
+            image = consumeImageSet(range, context);
             if (!image)
                 return nullptr;
         } else {
             break;
         }
 
         double num;
         IntPoint hotSpot(-1, -1);
         bool hotSpotSpecified = false;
         if (consumeNumberRaw(range, num)) {
             hotSpot.setX(int(num));
             if (!consumeNumberRaw(range, num))
                 return nullptr;
             hotSpot.setY(int(num));
             hotSpotSpecified = true;
         }
 
         if (!list)
             list = CSSValueList::createCommaSeparated();
 
         list->append(CSSCursorImageValue::create(image, hotSpotSpecified, hotSpot));
         if (!consumeCommaIncludingWhitespace(range))
             return nullptr;
     }
 
     CSSValueID id = range.peek().id();
-    if (!range.atEnd() && m_context.useCounter()) {
+    if (!range.atEnd() && context.useCounter()) {
         if (id == CSSValueWebkitZoomIn)
-            m_context.useCounter()->count(UseCounter::PrefixedCursorZoomIn);
+            context.useCounter()->count(UseCounter::PrefixedCursorZoomIn);
         else if (id == CSSValueWebkitZoomOut)
-            m_context.useCounter()->count(UseCounter::PrefixedCursorZoomOut);
+            context.useCounter()->count(UseCounter::PrefixedCursorZoomOut);
     }
     RefPtrWillBeRawPtr<CSSValue> cursorType = nullptr;
     if (id == CSSValueHand) {
-        if (inQuirksMode()) // Non-standard behavior
+        if (inQuirksMode) // Non-standard behavior
             cursorType = cssValuePool().createIdentifierValue(CSSValuePointer);
         range.consumeIncludingWhitespace();
     } else if ((id >= CSSValueAuto && id <= CSSValueWebkitZoomOut) || id == CSSValueCopy || id == CSSValueNone) {
         cursorType = consumeIdent(range);
     }
 
     if (!list)
         return cursorType.release();
     if (cursorType)
         list->append(cursorType.release());
@@ skipping 209 matching lines @@
     case CSSPropertyStrokeDashoffset:
     case CSSPropertyCx:
     case CSSPropertyCy:
     case CSSPropertyX:
     case CSSPropertyY:
     case CSSPropertyR:
     case CSSPropertyRx:
     case CSSPropertyRy:
         return consumeLengthOrPercent(m_range, SVGAttributeMode, ValueRangeAll, UnitlessQuirk::Forbid);
     case CSSPropertyCursor:
-        return consumeCursor(m_range);
+        return consumeCursor(m_range, m_context, inQuirksMode());
     case CSSPropertyContain:
         return consumeContain(m_range);
     case CSSPropertyTransformOrigin:
         return consumeTransformOrigin(m_range, m_context.mode(), UnitlessQuirk::Forbid);
     default:
         return nullptr;
     }
 }
 
 static PassRefPtrWillBeRawPtr<CSSValueList> consumeFontFaceUnicodeRange(CSSParserTokenRange& range)
@@ skipping 13 matching lines @@
     } while (consumeCommaIncludingWhitespace(range));
 
     return values.release();
 }
 
 PassRefPtrWillBeRawPtr<CSSValue> CSSPropertyParser::consumeFontFaceSrcURI()
 {
     String url = consumeUrl(m_range);
     if (url.isNull())
         return nullptr;
-    RefPtrWillBeRawPtr<CSSFontFaceSrcValue> uriValue(CSSFontFaceSrcValue::create(completeURL(url), m_context.shouldCheckContentSecurityPolicy()));
+    RefPtrWillBeRawPtr<CSSFontFaceSrcValue> uriValue(CSSFontFaceSrcValue::create(m_context.completeURL(url), m_context.shouldCheckContentSecurityPolicy()));
     uriValue->setReferrer(m_context.referrer());
 
     if (m_range.peek().functionId() != CSSValueFormat)
         return uriValue.release();
 
     // FIXME: https://drafts.csswg.org/css-fonts says that format() contains a comma-separated list of strings,
     // but CSSFontFaceSrcValue stores only one format. Allowing one format for now.
     // FIXME: IdentToken should not be supported here.
     CSSParserTokenRange args = consumeFunction(m_range);
     const CSSParserToken& arg = args.consumeIncludingWhitespace();
@@ skipping 547 matching lines @@
         return consumeShorthandGreedily(flexFlowShorthand(), important);
     case CSSPropertyWebkitColumnRule:
         return consumeShorthandGreedily(webkitColumnRuleShorthand(), important);
     default:
         m_currentShorthand = oldShorthand;
         return false;
     }
 }
 
 } // namespace blink