CSSValue Immediates: Make CSSPrimitiveValue a container

Source/core/css/resolver/StyleBuilderCustom.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 2004-2005 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2006, 2007 Nicholas Shanks (webkit@nickshanks.com)
  * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
  * Copyright (C) 2007, 2008 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (c) 2011, Code Aurora Forum. All rights reserved.
@@ skipping 134 matching lines @@
 {
     Color color = state.parentStyle()->color();
     if (state.applyPropertyToRegularStyle())
         state.style()->setColor(color);
     if (state.applyPropertyToVisitedLinkStyle())
         state.style()->setVisitedLinkColor(color);
 }
 
 void StyleBuilderFunctions::applyValueCSSPropertyColor(StyleResolverState& state, CSSValue value)
 {
-    CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
+    CSSPrimitiveValue primitiveValue = toCSSPrimitiveValue(value);
     // As per the spec, 'color: currentColor' is treated as 'color: inherit'
     if (primitiveValue.getValueID() == CSSValueCurrentcolor) {
         applyInheritCSSPropertyColor(state);
         return;
     }
 
     if (state.applyPropertyToRegularStyle())
         state.style()->setColor(StyleBuilderConverter::convertColor(state, value));
     if (state.applyPropertyToVisitedLinkStyle())
         state.style()->setVisitedLinkColor(StyleBuilderConverter::convertColor(state, value, true));
@@ skipping 98 matching lines @@
 }
 
 void StyleBuilderFunctions::applyInheritCSSPropertyOutlineStyle(StyleResolverState& state)
 {
     state.style()->setOutlineStyleIsAuto(state.parentStyle()->outlineStyleIsAuto());
     state.style()->setOutlineStyle(state.parentStyle()->outlineStyle());
 }
 
 void StyleBuilderFunctions::applyValueCSSPropertyOutlineStyle(StyleResolverState& state, CSSValue value)
 {
-    CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
+    CSSPrimitiveValue primitiveValue = toCSSPrimitiveValue(value);
     state.style()->setOutlineStyleIsAuto(primitiveValue);
     state.style()->setOutlineStyle(primitiveValue);
 }
 
 void StyleBuilderFunctions::applyValueCSSPropertyResize(StyleResolverState& state, CSSValue value)
 {
-    CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
+    CSSPrimitiveValue primitiveValue = toCSSPrimitiveValue(value);
 
     EResize r = RESIZE_NONE;
     if (primitiveValue.getValueID() == CSSValueAuto) {
         if (Settings* settings = state.document().settings())
             r = settings->textAreasAreResizable() ? RESIZE_BOTH : RESIZE_NONE;
     } else {
         r = primitiveValue;
     }
     state.style()->setResize(r);
 }
 
 static float mmToPx(float mm) { return mm * cssPixelsPerMillimeter; }
 static float inchToPx(float inch) { return inch * cssPixelsPerInch; }
-static FloatSize getPageSizeFromName(CSSPrimitiveValue& pageSizeName)
+static FloatSize getPageSizeFromName(CSSPrimitiveValue pageSizeName)
 {
     switch (pageSizeName.getValueID()) {
     case CSSValueA5:
         return FloatSize(mmToPx(148), mmToPx(210));
     case CSSValueA4:
         return FloatSize(mmToPx(210), mmToPx(297));
     case CSSValueA3:
         return FloatSize(mmToPx(297), mmToPx(420));
     case CSSValueB5:
         return FloatSize(mmToPx(176), mmToPx(250));
@@ skipping 14 matching lines @@
 void StyleBuilderFunctions::applyInitialCSSPropertySize(StyleResolverState&) { }
 void StyleBuilderFunctions::applyInheritCSSPropertySize(StyleResolverState&) { }
 void StyleBuilderFunctions::applyValueCSSPropertySize(StyleResolverState& state, CSSValue value)
 {
     state.style()->resetPageSizeType();
     FloatSize size;
     PageSizeType pageSizeType = PAGE_SIZE_AUTO;
     CSSValueList& list = toCSSValueList(value);
     if (list.length() == 2) {
         // <length>{2} | <page-size> <orientation>
-        CSSPrimitiveValue& first = toCSSPrimitiveValue(list.item(0));
-        CSSPrimitiveValue& second = toCSSPrimitiveValue(list.item(1));
+        CSSPrimitiveValue first = toCSSPrimitiveValue(list.item(0));
+        CSSPrimitiveValue second = toCSSPrimitiveValue(list.item(1));
         if (first.isLength()) {
             // <length>{2}
             size = FloatSize(first.computeLength<float>(state.cssToLengthConversionData().copyWithAdjustedZoom(1.0)),
                 second.computeLength<float>(state.cssToLengthConversionData().copyWithAdjustedZoom(1.0)));
         } else {
             // <page-size> <orientation>
             size = getPageSizeFromName(first);
 
             ASSERT(second.getValueID() == CSSValueLandscape || second.getValueID() == CSSValuePortrait);
             if (second.getValueID() == CSSValueLandscape)
                 size = size.transposedSize();
         }
         pageSizeType = PAGE_SIZE_RESOLVED;
     } else {
         ASSERT(list.length() == 1);
         // <length> | auto | <page-size> | [ portrait | landscape]
-        CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(list.item(0));
+        CSSPrimitiveValue primitiveValue = toCSSPrimitiveValue(list.item(0));
         if (primitiveValue.isLength()) {
             // <length>
             pageSizeType = PAGE_SIZE_RESOLVED;
             float width = primitiveValue.computeLength<float>(state.cssToLengthConversionData().copyWithAdjustedZoom(1.0));
             size = FloatSize(width, width);
         } else {
             switch (primitiveValue.getValueID()) {
             case CSSValueAuto:
                 pageSizeType = PAGE_SIZE_AUTO;
                 break;
             case CSSValuePortrait:
                 pageSizeType = PAGE_SIZE_AUTO_PORTRAIT;
                 break;
             case CSSValueLandscape:
                 pageSizeType = PAGE_SIZE_AUTO_LANDSCAPE;
                 break;
             default:
                 // <page-size>
                 pageSizeType = PAGE_SIZE_RESOLVED;
                 size = getPageSizeFromName(primitiveValue);
             }
         }
     }
     state.style()->setPageSizeType(pageSizeType);
     state.style()->setPageSize(size);
 }
 
 void StyleBuilderFunctions::applyValueCSSPropertyTextAlign(StyleResolverState& state, CSSValue value)
 {
-    CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
+    CSSPrimitiveValue primitiveValue = toCSSPrimitiveValue(value);
     if (primitiveValue.isValueID() && primitiveValue.getValueID() != CSSValueWebkitMatchParent)
         state.style()->setTextAlign(primitiveValue);
     else if (state.parentStyle()->textAlign() == TASTART)
         state.style()->setTextAlign(state.parentStyle()->isLeftToRightDirection() ? LEFT : RIGHT);
     else if (state.parentStyle()->textAlign() == TAEND)
         state.style()->setTextAlign(state.parentStyle()->isLeftToRightDirection() ? RIGHT : LEFT);
     else
         state.style()->setTextAlign(state.parentStyle()->textAlign());
 }
 
@@ skipping 11 matching lines @@
     state.style()->setTextIndentType(ComputedStyle::initialTextIndentType());
 }
 
 void StyleBuilderFunctions::applyValueCSSPropertyTextIndent(StyleResolverState& state, CSSValue value)
 {
     Length lengthOrPercentageValue;
     TextIndentLine textIndentLineValue = ComputedStyle::initialTextIndentLine();
     TextIndentType textIndentTypeValue = ComputedStyle::initialTextIndentType();
 
     for (auto& listValue : toCSSValueList(value)) {
-        CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(listValue);
+        CSSPrimitiveValue primitiveValue = toCSSPrimitiveValue(listValue);
         if (!primitiveValue.getValueID())
             lengthOrPercentageValue = primitiveValue.convertToLength(state.cssToLengthConversionData());
         else if (primitiveValue.getValueID() == CSSValueEachLine)
             textIndentLineValue = TextIndentEachLine;
         else if (primitiveValue.getValueID() == CSSValueHanging)
             textIndentTypeValue = TextIndentHanging;
         else
             ASSERT_NOT_REACHED();
     }
 
@@ skipping 51 matching lines @@
 {
     float rotation = 0;
     MotionRotationType rotationType = MotionRotationFixed;
 
     ASSERT(value.isValueList());
     CSSValueList& list = toCSSValueList(value);
     int len = list.length();
     for (int i = 0; i < len; i++) {
         CSSValue item = list.item(i);
         ASSERT(item.isPrimitiveValue());
-        CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(item);
+        CSSPrimitiveValue primitiveValue = toCSSPrimitiveValue(item);
         if (primitiveValue.getValueID() == CSSValueAuto) {
             rotationType = MotionRotationAuto;
         } else if (primitiveValue.getValueID() == CSSValueReverse) {
             rotationType = MotionRotationAuto;
             rotation += 180;
         } else {
             rotation += primitiveValue.computeDegrees();
         }
     }
 
     state.style()->setMotionRotation(rotation);
     state.style()->setMotionRotationType(rotationType);
 }
 
 void StyleBuilderFunctions::applyInheritCSSPropertyVerticalAlign(StyleResolverState& state)
 {
     EVerticalAlign verticalAlign = state.parentStyle()->verticalAlign();
     state.style()->setVerticalAlign(verticalAlign);
     if (verticalAlign == LENGTH)
         state.style()->setVerticalAlignLength(state.parentStyle()->verticalAlignLength());
 }
 
 void StyleBuilderFunctions::applyValueCSSPropertyVerticalAlign(StyleResolverState& state, CSSValue value)
 {
-    CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
+    CSSPrimitiveValue primitiveValue = toCSSPrimitiveValue(value);
 
     if (primitiveValue.getValueID())
         state.style()->setVerticalAlign(primitiveValue);
     else
         state.style()->setVerticalAlignLength(primitiveValue.convertToLength(state.cssToLengthConversionData()));
 }
 
 static void resetEffectiveZoom(StyleResolverState& state)
 {
     // Reset the zoom in effect. This allows the setZoom method to accurately compute a new zoom in effect.
     state.setEffectiveZoom(state.parentStyle() ? state.parentStyle()->effectiveZoom() : ComputedStyle::initialZoom());
 }
 
 void StyleBuilderFunctions::applyInitialCSSPropertyZoom(StyleResolverState& state)
 {
     resetEffectiveZoom(state);
     state.setZoom(ComputedStyle::initialZoom());
 }
 
 void StyleBuilderFunctions::applyInheritCSSPropertyZoom(StyleResolverState& state)
 {
     resetEffectiveZoom(state);
     state.setZoom(state.parentStyle()->zoom());
 }
 
 void StyleBuilderFunctions::applyValueCSSPropertyZoom(StyleResolverState& state, CSSValue value)
 {
     ASSERT_WITH_SECURITY_IMPLICATION(value.isPrimitiveValue());
-    CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
+    CSSPrimitiveValue primitiveValue = toCSSPrimitiveValue(value);
 
     if (primitiveValue.getValueID() == CSSValueNormal) {
         resetEffectiveZoom(state);
         state.setZoom(ComputedStyle::initialZoom());
     } else if (primitiveValue.getValueID() == CSSValueReset) {
         state.setEffectiveZoom(ComputedStyle::initialZoom());
         state.setZoom(ComputedStyle::initialZoom());
     } else if (primitiveValue.getValueID() == CSSValueDocument) {
         float docZoom = state.rootElementStyle() ? state.rootElementStyle()->zoom() : ComputedStyle::initialZoom();
         state.setEffectiveZoom(docZoom);
@@ skipping 12 matching lines @@
 void StyleBuilderFunctions::applyValueCSSPropertyWebkitBorderImage(StyleResolverState& state, CSSValue value)
 {
     NinePieceImage image;
     CSSToStyleMap::mapNinePieceImage(state, CSSPropertyWebkitBorderImage, value, image);
     state.style()->setBorderImage(image);
 }
 
 void StyleBuilderFunctions::applyValueCSSPropertyWebkitClipPath(StyleResolverState& state, CSSValue value)
 {
     if (value.isPrimitiveValue()) {
-        CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
+        CSSPrimitiveValue primitiveValue = toCSSPrimitiveValue(value);
         if (primitiveValue.getValueID() == CSSValueNone) {
             state.style()->setClipPath(nullptr);
         } else if (primitiveValue.isShape()) {
             state.style()->setClipPath(ShapeClipPathOperation::create(basicShapeForValue(state, primitiveValue.getShapeValue())));
         } else if (primitiveValue.primitiveType() == CSSPrimitiveValue::CSS_URI) {
             String cssURLValue = primitiveValue.getStringValue();
             KURL url = state.document().completeURL(cssURLValue);
             // FIXME: It doesn't work with forward or external SVG references (see https://bugs.webkit.org/show_bug.cgi?id=90405)
             state.style()->setClipPath(ReferenceClipPathOperation::create(cssURLValue, AtomicString(url.fragmentIdentifier())));
         }
@@ skipping 20 matching lines @@
     state.style()->setTextEmphasisMark(state.parentStyle()->textEmphasisMark());
     state.style()->setTextEmphasisCustomMark(state.parentStyle()->textEmphasisCustomMark());
 }
 
 void StyleBuilderFunctions::applyValueCSSPropertyWebkitTextEmphasisStyle(StyleResolverState& state, CSSValue value)
 {
     if (value.isValueList()) {
         CSSValueList& list = toCSSValueList(value);
         ASSERT(list.length() == 2);
         for (unsigned i = 0; i < 2; ++i) {
-            CSSPrimitiveValue& value = toCSSPrimitiveValue(list.item(i));
+            CSSPrimitiveValue value = toCSSPrimitiveValue(list.item(i));
             if (value.getValueID() == CSSValueFilled || value.getValueID() == CSSValueOpen)
                 state.style()->setTextEmphasisFill(value);
             else
                 state.style()->setTextEmphasisMark(value);
         }
         state.style()->setTextEmphasisCustomMark(nullAtom);
         return;
     }
 
-    CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
+    CSSPrimitiveValue primitiveValue = toCSSPrimitiveValue(value);
 
     if (primitiveValue.isString()) {
         state.style()->setTextEmphasisFill(TextEmphasisFillFilled);
         state.style()->setTextEmphasisMark(TextEmphasisMarkCustom);
         state.style()->setTextEmphasisCustomMark(AtomicString(primitiveValue.getStringValue()));
         return;
     }
 
     state.style()->setTextEmphasisCustomMark(nullAtom);
 
@@ skipping 23 matching lines @@
 }
 
 void StyleBuilderFunctions::applyValueCSSPropertyWillChange(StyleResolverState& state, CSSValue value)
 {
     ASSERT(value.isValueList());
     bool willChangeContents = false;
     bool willChangeScrollPosition = false;
     Vector<CSSPropertyID> willChangeProperties;
 
     for (auto& willChangeValue : toCSSValueList(value)) {
-        CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(willChangeValue);
+        CSSPrimitiveValue primitiveValue = toCSSPrimitiveValue(willChangeValue);
         if (CSSPropertyID propertyID = primitiveValue.getPropertyID())
             willChangeProperties.append(propertyID);
         else if (primitiveValue.getValueID() == CSSValueContents)
             willChangeContents = true;
         else if (primitiveValue.getValueID() == CSSValueScrollPosition)
             willChangeScrollPosition = true;
         else
             ASSERT_NOT_REACHED();
     }
     state.style()->setWillChangeContents(willChangeContents);
@@ skipping 29 matching lines @@
 
         if (item.isImageValue()) {
             state.style()->setContent(state.elementStyleResources().cachedOrPendingFromValue(state.document(), CSSPropertyContent, toCSSImageValue(item)), didSet);
             didSet = true;
             continue;
         }
 
         if (!item.isPrimitiveValue())
             continue;
 
-        CSSPrimitiveValue& contentValue = toCSSPrimitiveValue(item);
+        CSSPrimitiveValue contentValue = toCSSPrimitiveValue(item);
 
         if (contentValue.isString()) {
             state.style()->setContent(contentValue.getStringValue().impl(), didSet);
             didSet = true;
         } else if (contentValue.isAttr()) {
             // FIXME: Can a namespace be specified for an attr(foo)?
             if (state.style()->styleType() == NOPSEUDO)
                 state.style()->setUnique();
             else
                 state.parentStyle()->setUnique();
@@ skipping 33 matching lines @@
                 { }
             }
         }
     }
     if (!didSet)
         state.style()->clearContent();
 }
 
 void StyleBuilderFunctions::applyValueCSSPropertyWebkitLocale(StyleResolverState& state, CSSValue value)
 {
-    const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
+    const CSSPrimitiveValue primitiveValue = toCSSPrimitiveValue(value);
     if (primitiveValue.getValueID() == CSSValueAuto)
         state.style()->setLocale(nullAtom);
     else
         state.style()->setLocale(AtomicString(primitiveValue.getStringValue()));
     state.fontBuilder().setScript(state.style()->locale());
 }
 
 void StyleBuilderFunctions::applyInitialCSSPropertyWebkitAppRegion(StyleResolverState&)
 {
 }
 
 void StyleBuilderFunctions::applyInheritCSSPropertyWebkitAppRegion(StyleResolverState&)
 {
 }
 
 void StyleBuilderFunctions::applyValueCSSPropertyWebkitAppRegion(StyleResolverState& state, CSSValue value)
 {
-    const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
+    const CSSPrimitiveValue primitiveValue = toCSSPrimitiveValue(value);
     state.style()->setDraggableRegionMode(primitiveValue.getValueID() == CSSValueDrag ? DraggableRegionDrag : DraggableRegionNoDrag);
     state.document().setHasAnnotatedRegions(true);
 }
 
 void StyleBuilderFunctions::applyValueCSSPropertyWebkitWritingMode(StyleResolverState& state, CSSValue value)
 {
     state.setWritingMode(toCSSPrimitiveValue(value));
 }
 
 void StyleBuilderFunctions::applyValueCSSPropertyWebkitTextOrientation(StyleResolverState& state, CSSValue value)
 {
     state.setTextOrientation(toCSSPrimitiveValue(value));
 }
 
 void StyleBuilderFunctions::applyInheritCSSPropertyBaselineShift(StyleResolverState& state)
 {
     const SVGComputedStyle& parentSvgStyle = state.parentStyle()->svgStyle();
     EBaselineShift baselineShift = parentSvgStyle.baselineShift();
     SVGComputedStyle& svgStyle = state.style()->accessSVGStyle();
     svgStyle.setBaselineShift(baselineShift);
     if (baselineShift == BS_LENGTH)
         svgStyle.setBaselineShiftValue(parentSvgStyle.baselineShiftValue());
 }
 
 void StyleBuilderFunctions::applyValueCSSPropertyBaselineShift(StyleResolverState& state, CSSValue value)
 {
     SVGComputedStyle& svgStyle = state.style()->accessSVGStyle();
-    CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
+    CSSPrimitiveValue primitiveValue = toCSSPrimitiveValue(value);
     if (!primitiveValue.isValueID()) {
         svgStyle.setBaselineShift(BS_LENGTH);
         svgStyle.setBaselineShiftValue(StyleBuilderConverter::convertLength(state, value));
         return;
     }
     switch (primitiveValue.getValueID()) {
     case CSSValueBaseline:
         svgStyle.setBaselineShift(BS_LENGTH);
         svgStyle.setBaselineShiftValue(Length(Fixed));
         return;
     case CSSValueSub:
         svgStyle.setBaselineShift(BS_SUB);
         return;
     case CSSValueSuper:
         svgStyle.setBaselineShift(BS_SUPER);
         return;
     default:
         ASSERT_NOT_REACHED();
     }
 }
 
 } // namespace blink