Split out String, URI and CustomIdent from CSSPrimitiveValue

Source/core/css/ComputedStyleCSSValueMapping.cpp

 /*
  * Copyright (C) 2004 Zack Rusin <zack@kde.org>
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
  * Copyright (C) 2007 Nicholas Shanks <webkit@nickshanks.com>
  * Copyright (C) 2011 Sencha, Inc. All rights reserved.
  * Copyright (C) 2015 Google Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ skipping 21 matching lines @@
 #include "core/css/CSSCounterValue.h"
 #include "core/css/CSSFontFeatureValue.h"
 #include "core/css/CSSFunctionValue.h"
 #include "core/css/CSSGridLineNamesValue.h"
 #include "core/css/CSSGridTemplateAreasValue.h"
 #include "core/css/CSSPathValue.h"
 #include "core/css/CSSPrimitiveValueMappings.h"
 #include "core/css/CSSQuadValue.h"
 #include "core/css/CSSReflectValue.h"
 #include "core/css/CSSShadowValue.h"
+#include "core/css/CSSStringValue.h"
 #include "core/css/CSSTimingFunctionValue.h"
 #include "core/css/CSSValueList.h"
 #include "core/css/CSSValuePair.h"
 #include "core/css/CSSValuePool.h"
 #include "core/layout/LayoutBlock.h"
 #include "core/layout/LayoutBox.h"
 #include "core/layout/LayoutGrid.h"
 #include "core/layout/LayoutObject.h"
 #include "core/style/ComputedStyle.h"
 #include "core/style/ContentData.h"
@@ skipping 431 matching lines @@
         return CSSValueMonospace;
     if (family == FontFamilyNames::webkit_pictograph)
         return CSSValueWebkitPictograph;
     if (family == FontFamilyNames::webkit_sans_serif)
         return CSSValueSansSerif;
     if (family == FontFamilyNames::webkit_serif)
         return CSSValueSerif;
     return CSSValueInvalid;
 }
 
-static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> valueForFamily(const AtomicString& family)
+static PassRefPtrWillBeRawPtr<CSSValue> valueForFamily(const AtomicString& family)
 {
     if (CSSValueID familyIdentifier = identifierForFamily(family))
         return cssValuePool().createIdentifierValue(familyIdentifier);
-    return cssValuePool().createValue(family.string(), CSSPrimitiveValue::UnitType::CustomIdentifier);
+    return CSSStringValue::create(family.string(), CSSStringValue::SerializeAsCustomIdentifier);
 }
 
 static PassRefPtrWillBeRawPtr<CSSValueList> valueForFontFamily(const ComputedStyle& style)
 {
     const FontFamily& firstFamily = style.fontDescription().family();
     RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
     for (const FontFamily* family = &firstFamily; family; family = family->next())
         list->append(valueForFamily(family->family()));
     return list.release();
 }
@@ skipping 50 matching lines @@
 }
 
 static void addValuesForNamedGridLinesAtIndex(const OrderedNamedGridLines& orderedNamedGridLines, size_t i, CSSValueList& list)
 {
     const Vector<String>& namedGridLines = orderedNamedGridLines.get(i);
     if (namedGridLines.isEmpty())
         return;
 
     RefPtrWillBeRawPtr<CSSGridLineNamesValue> lineNames = CSSGridLineNamesValue::create();
     for (size_t j = 0; j < namedGridLines.size(); ++j)
-        lineNames->append(cssValuePool().createValue(namedGridLines[j], CSSPrimitiveValue::UnitType::CustomIdentifier));
+        lineNames->append(CSSStringValue::create(namedGridLines[j], CSSStringValue::SerializeAsCustomIdentifier));
     list.append(lineNames.release());
 }
 
 static PassRefPtrWillBeRawPtr<CSSValue> valueForGridTrackList(GridTrackSizingDirection direction, const LayoutObject* layoutObject, const ComputedStyle& style)
 {
     const Vector<GridTrackSize>& trackSizes = direction == ForColumns ? style.gridTemplateColumns() : style.gridTemplateRows();
     const OrderedNamedGridLines& orderedNamedGridLines = direction == ForColumns ? style.orderedNamedGridColumnLines() : style.orderedNamedGridRowLines();
     bool isLayoutGrid = layoutObject && layoutObject->isLayoutGrid();
 
     // Handle the 'none' case.
@@ skipping 34 matching lines @@
     addValuesForNamedGridLinesAtIndex(orderedNamedGridLines, insertionIndex, *list);
     return list.release();
 }
 
 static PassRefPtrWillBeRawPtr<CSSValue> valueForGridPosition(const GridPosition& position)
 {
     if (position.isAuto())
         return cssValuePool().createIdentifierValue(CSSValueAuto);
 
     if (position.isNamedGridArea())
-        return cssValuePool().createValue(position.namedGridLine(), CSSPrimitiveValue::UnitType::CustomIdentifier);
+        return CSSStringValue::create(position.namedGridLine(), CSSStringValue::SerializeAsCustomIdentifier);
 
     RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
     if (position.isSpan()) {
         list->append(cssValuePool().createIdentifierValue(CSSValueSpan));
         list->append(cssValuePool().createValue(position.spanPosition(), CSSPrimitiveValue::UnitType::Number));
     } else {
         list->append(cssValuePool().createValue(position.integerPosition(), CSSPrimitiveValue::UnitType::Number));
     }
 
     if (!position.namedGridLine().isNull())
-        list->append(cssValuePool().createValue(position.namedGridLine(), CSSPrimitiveValue::UnitType::CustomIdentifier));
+        list->append(CSSStringValue::create(position.namedGridLine(), CSSStringValue::SerializeAsCustomIdentifier));
     return list;
 }
 
 static LayoutRect sizingBox(const LayoutObject* layoutObject)
 {
     if (!layoutObject->isBox())
         return LayoutRect();
 
     const LayoutBox* box = toLayoutBox(layoutObject);
     return box->style()->boxSizing() == BORDER_BOX ? box->borderBoxRect() : box->computedCSSContentBoxRect();
@@ skipping 289 matching lines @@
     list->append(valueForMatrixTransform(transform, style));
 
     return list.release();
 }
 
 static PassRefPtrWillBeRawPtr<CSSValue> createTransitionPropertyValue(const CSSTransitionData::TransitionProperty& property)
 {
     if (property.propertyType == CSSTransitionData::TransitionNone)
         return cssValuePool().createIdentifierValue(CSSValueNone);
     if (property.propertyType == CSSTransitionData::TransitionUnknownProperty)
-        return cssValuePool().createValue(property.propertyString, CSSPrimitiveValue::UnitType::CustomIdentifier);
+        return CSSStringValue::create(property.propertyString, CSSStringValue::SerializeAsCustomIdentifier);
     ASSERT(property.propertyType == CSSTransitionData::TransitionKnownProperty);
-    return cssValuePool().createValue(getPropertyNameString(property.unresolvedProperty), CSSPrimitiveValue::UnitType::CustomIdentifier);
+    return CSSStringValue::create(getPropertyNameString(property.unresolvedProperty), CSSStringValue::SerializeAsCustomIdentifier);
 }
 
 static PassRefPtrWillBeRawPtr<CSSValue> valueForTransitionProperty(const CSSTransitionData* transitionData)
 {
     RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
     if (transitionData) {
         for (size_t i = 0; i < transitionData->propertyList().size(); ++i)
             list->append(createTransitionPropertyValue(transitionData->propertyList()[i]));
     } else {
         list->append(cssValuePool().createIdentifierValue(CSSValueAll));
@@ skipping 24 matching lines @@
     return CSSValueInvalid;
 }
 
 static PassRefPtrWillBeRawPtr<CSSValue> valueForContentData(const ComputedStyle& style)
 {
     RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
     for (const ContentData* contentData = style.contentData(); contentData; contentData = contentData->next()) {
         if (contentData->isCounter()) {
             const CounterContent* counter = toCounterContentData(contentData)->counter();
             ASSERT(counter);
-            RefPtrWillBeRawPtr<CSSPrimitiveValue> identifier = cssValuePool().createValue(counter->identifier(), CSSPrimitiveValue::UnitType::CustomIdentifier);
-            RefPtrWillBeRawPtr<CSSPrimitiveValue> separator = cssValuePool().createValue(counter->separator(), CSSPrimitiveValue::UnitType::CustomIdentifier);
+            RefPtrWillBeRawPtr<CSSStringValue> identifier = CSSStringValue::create(counter->identifier(), CSSStringValue::SerializeAsCustomIdentifier);
+            RefPtrWillBeRawPtr<CSSStringValue> separator = CSSStringValue::create(counter->separator(), CSSStringValue::SerializeAsCustomIdentifier);
             CSSValueID listStyleIdent = CSSValueNone;
             if (counter->listStyle() != NoneListStyle)
                 listStyleIdent = static_cast<CSSValueID>(CSSValueDisc + counter->listStyle());
             RefPtrWillBeRawPtr<CSSPrimitiveValue> listStyle = cssValuePool().createIdentifierValue(listStyleIdent);
             list->append(CSSCounterValue::create(identifier.release(), listStyle.release(), separator.release()));
         } else if (contentData->isImage()) {
             const StyleImage* image = toImageContentData(contentData)->image();
             ASSERT(image);
             list->append(image->cssValue());
         } else if (contentData->isText()) {
-            list->append(cssValuePool().createValue(toTextContentData(contentData)->text(), CSSPrimitiveValue::UnitType::String));
+            list->append(CSSStringValue::create(toTextContentData(contentData)->text(), CSSStringValue::SerializeAsString));
         } else if (contentData->isQuote()) {
             const QuoteType quoteType = toQuoteContentData(contentData)->quote();
             list->append(cssValuePool().createIdentifierValue(valueForQuoteType(quoteType)));
         } else {
             ASSERT_NOT_REACHED();
         }
     }
     return list.release();
 }
 
 static PassRefPtrWillBeRawPtr<CSSValue> valueForCounterDirectives(const ComputedStyle& style, CSSPropertyID propertyID)
 {
     const CounterDirectiveMap* map = style.counterDirectives();
     if (!map)
         return cssValuePool().createIdentifierValue(CSSValueNone);
 
     RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
     for (const auto& item : *map) {
         bool isValidCounterValue = propertyID == CSSPropertyCounterIncrement ? item.value.isIncrement() : item.value.isReset();
         if (!isValidCounterValue)
             continue;
 
-        list->append(cssValuePool().createValue(item.key, CSSPrimitiveValue::UnitType::CustomIdentifier));
+        list->append(CSSStringValue::create(item.key, CSSStringValue::SerializeAsCustomIdentifier));
         short number = propertyID == CSSPropertyCounterIncrement ? item.value.incrementValue() : item.value.resetValue();
         list->append(cssValuePool().createValue((double)number, CSSPrimitiveValue::UnitType::Number));
     }
 
     if (!list->length())
         return cssValuePool().createIdentifierValue(CSSValueNone);
 
     return list.release();
 }
 
@@ skipping 135 matching lines @@
         }
     }
 
     return list.release();
 }
 
 static PassRefPtrWillBeRawPtr<CSSValue> adjustSVGPaintForCurrentColor(SVGPaintType paintType, const String& url, const Color& color, const Color& currentColor)
 {
     if (paintType >= SVG_PAINTTYPE_URI_NONE) {
         RefPtrWillBeRawPtr<CSSValueList> values = CSSValueList::createSpaceSeparated();
-        values->append(CSSPrimitiveValue::create(url, CSSPrimitiveValue::UnitType::URI));
+        values->append(CSSStringValue::create(url, CSSStringValue::SerializeAsURI));
         if (paintType == SVG_PAINTTYPE_URI_NONE)
             values->append(CSSPrimitiveValue::create(CSSValueNone));
         else if (paintType == SVG_PAINTTYPE_URI_CURRENTCOLOR)
             values->append(CSSPrimitiveValue::createColor(currentColor.rgb()));
         else if (paintType == SVG_PAINTTYPE_URI_RGBCOLOR)
             values->append(CSSPrimitiveValue::createColor(color.rgb()));
         return values.release();
     }
     if (paintType == SVG_PAINTTYPE_NONE)
         return CSSPrimitiveValue::create(CSSValueNone);
@@ skipping 38 matching lines @@
 
     RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
 
     RefPtrWillBeRawPtr<CSSFunctionValue> filterValue = nullptr;
 
     for (const auto& operation : style.filter().operations()) {
         FilterOperation* filterOperation = operation.get();
         switch (filterOperation->type()) {
         case FilterOperation::REFERENCE:
             filterValue = CSSFunctionValue::create(CSSValueUrl);
-            filterValue->append(cssValuePool().createValue(toReferenceFilterOperation(filterOperation)->url(), CSSPrimitiveValue::UnitType::CustomIdentifier));
+            filterValue->append(CSSStringValue::create(toReferenceFilterOperation(filterOperation)->url(), CSSStringValue::SerializeAsCustomIdentifier));
             break;
         case FilterOperation::GRAYSCALE:
             filterValue = CSSFunctionValue::create(CSSValueGrayscale);
             filterValue->append(cssValuePool().createValue(toBasicColorMatrixFilterOperation(filterOperation)->amount(), CSSPrimitiveValue::UnitType::Number));
             break;
         case FilterOperation::SEPIA:
             filterValue = CSSFunctionValue::create(CSSValueSepia);
             filterValue->append(cssValuePool().createValue(toBasicColorMatrixFilterOperation(filterOperation)->amount(), CSSPrimitiveValue::UnitType::Number));
             break;
         case FilterOperation::SATURATE:
@@ skipping 455 matching lines @@
             // According to http://www.w3.org/TR/CSS2/visudet.html#the-height-property,
             // the "height" property does not apply for non-replaced inline elements.
             if (!layoutObject->isReplaced() && layoutObject->isInline())
                 return cssValuePool().createIdentifierValue(CSSValueAuto);
             return zoomAdjustedPixelValue(sizingBox(layoutObject).height(), style);
         }
         return zoomAdjustedPixelValueForLength(style.height(), style);
     case CSSPropertyWebkitHighlight:
         if (style.highlight() == nullAtom)
             return cssValuePool().createIdentifierValue(CSSValueNone);
-        return cssValuePool().createValue(style.highlight(), CSSPrimitiveValue::UnitType::String);
+        return CSSStringValue::create(style.highlight(), CSSStringValue::SerializeAsString);
     case CSSPropertyWebkitHyphenateCharacter:
         if (style.hyphenationString().isNull())
             return cssValuePool().createIdentifierValue(CSSValueAuto);
-        return cssValuePool().createValue(style.hyphenationString(), CSSPrimitiveValue::UnitType::String);
+        return CSSStringValue::create(style.hyphenationString(), CSSStringValue::SerializeAsString);
     case CSSPropertyImageRendering:
         return CSSPrimitiveValue::create(style.imageRendering());
     case CSSPropertyImageOrientation:
         if (style.respectImageOrientation() == RespectImageOrientation)
             return cssValuePool().createValue(CSSValueFromImage);
         return cssValuePool().createValue(0, CSSPrimitiveValue::UnitType::Degrees);
     case CSSPropertyIsolation:
         return cssValuePool().createValue(style.isolation());
     case CSSPropertyJustifyItems:
         return valueForItemPositionWithOverflowAlignment(resolveAlignmentAuto(style.justifyItemsPosition(), styledNode), style.justifyItemsOverflowAlignment(), style.justifyItemsPositionType());
@@ skipping 15 matching lines @@
         if (style.listStyleImage())
             return style.listStyleImage()->cssValue();
         return cssValuePool().createIdentifierValue(CSSValueNone);
     case CSSPropertyListStylePosition:
         return cssValuePool().createValue(style.listStylePosition());
     case CSSPropertyListStyleType:
         return cssValuePool().createValue(style.listStyleType());
     case CSSPropertyWebkitLocale:
         if (style.locale().isNull())
             return cssValuePool().createIdentifierValue(CSSValueAuto);
-        return cssValuePool().createValue(style.locale(), CSSPrimitiveValue::UnitType::String);
+        return CSSStringValue::create(style.locale(), CSSStringValue::SerializeAsString);
     case CSSPropertyMarginTop: {
         Length marginTop = style.marginTop();
         if (marginTop.isFixed() || !layoutObject || !layoutObject->isBox())
             return zoomAdjustedPixelValueForLength(marginTop, style);
         return zoomAdjustedPixelValue(toLayoutBox(layoutObject)->marginTop(), style);
     }
     case CSSPropertyMarginRight: {
         Length marginRight = style.marginRight();
         if (marginRight.isFixed() || !layoutObject || !layoutObject->isBox())
             return zoomAdjustedPixelValueForLength(marginRight, style);
@@ skipping 117 matching lines @@
     case CSSPropertyPosition:
         return cssValuePool().createValue(style.position());
     case CSSPropertyQuotes:
         if (!style.quotes()) {
             // TODO(ramya.v): We should return the quote values that we're actually using.
             return nullptr;
         }
         if (style.quotes()->size()) {
             RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
             for (int i = 0; i < style.quotes()->size(); i++) {
-                list->append(cssValuePool().createValue(style.quotes()->getOpenQuote(i), CSSPrimitiveValue::UnitType::String));
-                list->append(cssValuePool().createValue(style.quotes()->getCloseQuote(i), CSSPrimitiveValue::UnitType::String));
+                list->append(CSSStringValue::create(style.quotes()->getOpenQuote(i), CSSStringValue::SerializeAsString));
+                list->append(CSSStringValue::create(style.quotes()->getCloseQuote(i), CSSStringValue::SerializeAsString));
             }
             return list.release();
         }
         return cssValuePool().createIdentifierValue(CSSValueNone);
     case CSSPropertyRight:
         return valueForPositionOffset(style, CSSPropertyRight, layoutObject);
     case CSSPropertyWebkitRubyPosition:
         return cssValuePool().createValue(style.rubyPosition());
     case CSSPropertyScrollBehavior:
         return cssValuePool().createValue(style.scrollBehavior());
@@ skipping 23 matching lines @@
         return currentColorOrValidColor(style, style.textFillColor());
     case CSSPropertyWebkitTextEmphasisColor:
         return currentColorOrValidColor(style, style.textEmphasisColor());
     case CSSPropertyWebkitTextEmphasisPosition:
         return cssValuePool().createValue(style.textEmphasisPosition());
     case CSSPropertyWebkitTextEmphasisStyle:
         switch (style.textEmphasisMark()) {
         case TextEmphasisMarkNone:
             return cssValuePool().createIdentifierValue(CSSValueNone);
         case TextEmphasisMarkCustom:
-            return cssValuePool().createValue(style.textEmphasisCustomMark(), CSSPrimitiveValue::UnitType::String);
+            return CSSStringValue::create(style.textEmphasisCustomMark(), CSSStringValue::SerializeAsString);
         case TextEmphasisMarkAuto:
             ASSERT_NOT_REACHED();
             // Fall through
         case TextEmphasisMarkDot:
         case TextEmphasisMarkCircle:
         case TextEmphasisMarkDoubleCircle:
         case TextEmphasisMarkTriangle:
         case TextEmphasisMarkSesame: {
             RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
             list->append(cssValuePool().createValue(style.textEmphasisFill()));
@@ skipping 157 matching lines @@
         } else {
             list->append(cssValuePool().createValue(CSSAnimationData::initialIterationCount(), CSSPrimitiveValue::UnitType::Number));
         }
         return list.release();
     }
     case CSSPropertyAnimationName: {
         RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
         const CSSAnimationData* animationData = style.animations();
         if (animationData) {
             for (size_t i = 0; i < animationData->nameList().size(); ++i)
-                list->append(cssValuePool().createValue(animationData->nameList()[i], CSSPrimitiveValue::UnitType::CustomIdentifier));
+                list->append(CSSStringValue::create(animationData->nameList()[i], CSSStringValue::SerializeAsCustomIdentifier));
         } else {
             list->append(cssValuePool().createIdentifierValue(CSSValueNone));
         }
         return list.release();
     }
     case CSSPropertyAnimationPlayState: {
         RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
         const CSSAnimationData* animationData = style.animations();
         if (animationData) {
             for (size_t i = 0; i < animationData->playStateList().size(); ++i)
                 list->append(valueForAnimationPlayState(animationData->playStateList()[i]));
         } else {
             list->append(cssValuePool().createIdentifierValue(CSSValueRunning));
         }
         return list.release();
     }
     case CSSPropertyAnimationTimingFunction:
         return valueForAnimationTimingFunction(style.animations());
     case CSSPropertyAnimation: {
         const CSSAnimationData* animationData = style.animations();
         if (animationData) {
             RefPtrWillBeRawPtr<CSSValueList> animationsList = CSSValueList::createCommaSeparated();
             for (size_t i = 0; i < animationData->nameList().size(); ++i) {
                 RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
-                list->append(cssValuePool().createValue(animationData->nameList()[i], CSSPrimitiveValue::UnitType::CustomIdentifier));
+                list->append(CSSStringValue::create(animationData->nameList()[i], CSSStringValue::SerializeAsCustomIdentifier));
                 list->append(cssValuePool().createValue(CSSTimingData::getRepeated(animationData->durationList(), i), CSSPrimitiveValue::UnitType::Seconds));
                 list->append(createTimingFunctionValue(CSSTimingData::getRepeated(animationData->timingFunctionList(), i).get()));
                 list->append(cssValuePool().createValue(CSSTimingData::getRepeated(animationData->delayList(), i), CSSPrimitiveValue::UnitType::Seconds));
                 list->append(valueForAnimationIterationCount(CSSTimingData::getRepeated(animationData->iterationCountList(), i)));
                 list->append(valueForAnimationDirection(CSSTimingData::getRepeated(animationData->directionList(), i)));
                 list->append(valueForAnimationFillMode(CSSTimingData::getRepeated(animationData->fillModeList(), i)));
                 list->append(valueForAnimationPlayState(CSSTimingData::getRepeated(animationData->playStateList(), i)));
                 animationsList->append(list);
             }
             return animationsList.release();
@@ skipping 163 matching lines @@
         return valueForContentData(style);
     case CSSPropertyCounterIncrement:
         return valueForCounterDirectives(style, propertyID);
     case CSSPropertyCounterReset:
         return valueForCounterDirectives(style, propertyID);
     case CSSPropertyWebkitClipPath:
         if (ClipPathOperation* operation = style.clipPath()) {
             if (operation->type() == ClipPathOperation::SHAPE)
                 return valueForBasicShape(style, toShapeClipPathOperation(operation)->basicShape());
             if (operation->type() == ClipPathOperation::REFERENCE)
-                return CSSPrimitiveValue::create(toReferenceClipPathOperation(operation)->url(), CSSPrimitiveValue::UnitType::URI);
+                return CSSStringValue::create(toReferenceClipPathOperation(operation)->url(), CSSStringValue::SerializeAsURI);
         }
         return cssValuePool().createIdentifierValue(CSSValueNone);
     case CSSPropertyShapeMargin:
         return cssValuePool().createValue(style.shapeMargin(), style);
     case CSSPropertyShapeImageThreshold:
         return cssValuePool().createValue(style.shapeImageThreshold(), CSSPrimitiveValue::UnitType::Number);
     case CSSPropertyShapeOutside:
         return valueForShape(style, style.shapeOutside());
     case CSSPropertyWebkitFilter:
         return valueForFilter(style);
@@ skipping 181 matching lines @@
     case CSSPropertyAlignmentBaseline:
         return CSSPrimitiveValue::create(svgStyle.alignmentBaseline());
     case CSSPropertyDominantBaseline:
         return CSSPrimitiveValue::create(svgStyle.dominantBaseline());
     case CSSPropertyTextAnchor:
         return CSSPrimitiveValue::create(svgStyle.textAnchor());
     case CSSPropertyWritingMode:
         return CSSPrimitiveValue::create(svgStyle.writingMode());
     case CSSPropertyClipPath:
         if (!svgStyle.clipperResource().isEmpty())
-            return CSSPrimitiveValue::create(serializeAsFragmentIdentifier(svgStyle.clipperResource()), CSSPrimitiveValue::UnitType::URI);
+            return CSSStringValue::create(serializeAsFragmentIdentifier(svgStyle.clipperResource()), CSSStringValue::SerializeAsURI);
         return CSSPrimitiveValue::createIdentifier(CSSValueNone);
     case CSSPropertyMask:
         if (!svgStyle.maskerResource().isEmpty())
-            return CSSPrimitiveValue::create(serializeAsFragmentIdentifier(svgStyle.maskerResource()), CSSPrimitiveValue::UnitType::URI);
+            return CSSStringValue::create(serializeAsFragmentIdentifier(svgStyle.maskerResource()), CSSStringValue::SerializeAsURI);
         return CSSPrimitiveValue::createIdentifier(CSSValueNone);
     case CSSPropertyFilter:
         if (!svgStyle.filterResource().isEmpty())
-            return CSSPrimitiveValue::create(serializeAsFragmentIdentifier(svgStyle.filterResource()), CSSPrimitiveValue::UnitType::URI);
+            return CSSStringValue::create(serializeAsFragmentIdentifier(svgStyle.filterResource()), CSSStringValue::SerializeAsURI);
         return CSSPrimitiveValue::createIdentifier(CSSValueNone);
     case CSSPropertyFloodColor:
         return currentColorOrValidColor(style, svgStyle.floodColor());
     case CSSPropertyLightingColor:
         return currentColorOrValidColor(style, svgStyle.lightingColor());
     case CSSPropertyStopColor:
         return currentColorOrValidColor(style, svgStyle.stopColor());
     case CSSPropertyFill:
         return adjustSVGPaintForCurrentColor(svgStyle.fillPaintType(), svgStyle.fillPaintUri(), svgStyle.fillPaintColor(), style.color());
     case CSSPropertyMarkerEnd:
         if (!svgStyle.markerEndResource().isEmpty())
-            return CSSPrimitiveValue::create(serializeAsFragmentIdentifier(svgStyle.markerEndResource()), CSSPrimitiveValue::UnitType::URI);
+            return CSSStringValue::create(serializeAsFragmentIdentifier(svgStyle.markerEndResource()), CSSStringValue::SerializeAsURI);
         return CSSPrimitiveValue::createIdentifier(CSSValueNone);
     case CSSPropertyMarkerMid:
         if (!svgStyle.markerMidResource().isEmpty())
-            return CSSPrimitiveValue::create(serializeAsFragmentIdentifier(svgStyle.markerMidResource()), CSSPrimitiveValue::UnitType::URI);
+            return CSSStringValue::create(serializeAsFragmentIdentifier(svgStyle.markerMidResource()), CSSStringValue::SerializeAsURI);
         return CSSPrimitiveValue::createIdentifier(CSSValueNone);
     case CSSPropertyMarkerStart:
         if (!svgStyle.markerStartResource().isEmpty())
-            return CSSPrimitiveValue::create(serializeAsFragmentIdentifier(svgStyle.markerStartResource()), CSSPrimitiveValue::UnitType::URI);
+            return CSSStringValue::create(serializeAsFragmentIdentifier(svgStyle.markerStartResource()), CSSStringValue::SerializeAsURI);
         return CSSPrimitiveValue::createIdentifier(CSSValueNone);
     case CSSPropertyStroke:
         return adjustSVGPaintForCurrentColor(svgStyle.strokePaintType(), svgStyle.strokePaintUri(), svgStyle.strokePaintColor(), style.color());
     case CSSPropertyStrokeDasharray:
         return strokeDashArrayToCSSValueList(*svgStyle.strokeDashArray(), style);
     case CSSPropertyStrokeDashoffset:
         return zoomAdjustedPixelValueForLength(svgStyle.strokeDashOffset(), style);
     case CSSPropertyStrokeWidth:
         return pixelValueForUnzoomedLength(svgStyle.strokeWidth(), style);
     case CSSPropertyBaselineShift: {
@@ skipping 105 matching lines @@
     case CSSPropertyAll:
         return nullptr;
     default:
         break;
     }
     ASSERT_NOT_REACHED();
     return nullptr;
 }
 
 }