CSSValue Immediates: Add move operators to CSSPrimitiveValue

Source/core/css/resolver/CSSToStyleMap.cpp

 /*
  * 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 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.
  * Copyright (C) Research In Motion Limited 2011. All rights reserved.
@@ skipping 35 matching lines @@
 void CSSToStyleMap::mapFillAttachment(StyleResolverState&, FillLayer* layer, const CSSValue& value)
 {
     if (value.isInitialValue()) {
         layer->setAttachment(FillLayer::initialFillAttachment(layer->type()));
         return;
     }
 
     if (!value.isPrimitiveValue())
         return;
 
-    CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
+    const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
     switch (primitiveValue.getValueID()) {
     case CSSValueFixed:
         layer->setAttachment(FixedBackgroundAttachment);
         break;
     case CSSValueScroll:
         layer->setAttachment(ScrollBackgroundAttachment);
         break;
     case CSSValueLocal:
         layer->setAttachment(LocalBackgroundAttachment);
         break;
     default:
         return;
     }
 }
 
 void CSSToStyleMap::mapFillClip(StyleResolverState&, FillLayer* layer, const CSSValue& value)
 {
     if (value.isInitialValue()) {
         layer->setClip(FillLayer::initialFillClip(layer->type()));
         return;
     }
 
     if (!value.isPrimitiveValue())
         return;
 
-    CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
+    const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
     layer->setClip(primitiveValue);
 }
 
 void CSSToStyleMap::mapFillComposite(StyleResolverState&, FillLayer* layer, const CSSValue& value)
 {
     if (value.isInitialValue()) {
         layer->setComposite(FillLayer::initialFillComposite(layer->type()));
         return;
     }
 
     if (!value.isPrimitiveValue())
         return;
 
-    CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
+    const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
     layer->setComposite(primitiveValue);
 }
 
 void CSSToStyleMap::mapFillBlendMode(StyleResolverState&, FillLayer* layer, const CSSValue& value)
 {
     if (value.isInitialValue()) {
         layer->setBlendMode(FillLayer::initialFillBlendMode(layer->type()));
         return;
     }
 
     if (!value.isPrimitiveValue())
         return;
 
-    CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
+    const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
     layer->setBlendMode(primitiveValue);
 }
 
 void CSSToStyleMap::mapFillOrigin(StyleResolverState&, FillLayer* layer, const CSSValue& value)
 {
     if (value.isInitialValue()) {
         layer->setOrigin(FillLayer::initialFillOrigin(layer->type()));
         return;
     }
 
     if (!value.isPrimitiveValue())
         return;
 
-    CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
+    const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
     layer->setOrigin(primitiveValue);
 }
 
 
 void CSSToStyleMap::mapFillImage(StyleResolverState& state, FillLayer* layer, const CSSValue& value)
 {
     if (value.isInitialValue()) {
         layer->setImage(FillLayer::initialFillImage(layer->type()));
         return;
     }
 
     CSSPropertyID property = layer->type() == BackgroundFillLayer ? CSSPropertyBackgroundImage : CSSPropertyWebkitMaskImage;
     layer->setImage(state.styleImage(property, value));
 }
 
 void CSSToStyleMap::mapFillRepeatX(StyleResolverState&, FillLayer* layer, const CSSValue& value)
 {
     if (value.isInitialValue()) {
         layer->setRepeatX(FillLayer::initialFillRepeatX(layer->type()));
         return;
     }
 
     if (!value.isPrimitiveValue())
         return;
 
-    CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
+    const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
     layer->setRepeatX(primitiveValue);
 }
 
 void CSSToStyleMap::mapFillRepeatY(StyleResolverState&, FillLayer* layer, const CSSValue& value)
 {
     if (value.isInitialValue()) {
         layer->setRepeatY(FillLayer::initialFillRepeatY(layer->type()));
         return;
     }
 
     if (!value.isPrimitiveValue())
         return;
 
-    CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
+    const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
     layer->setRepeatY(primitiveValue);
 }
 
 void CSSToStyleMap::mapFillSize(StyleResolverState& state, FillLayer* layer, const CSSValue& value)
 {
     if (value.isInitialValue()) {
         layer->setSizeType(FillLayer::initialFillSizeType(layer->type()));
         layer->setSizeLength(FillLayer::initialFillSizeLength(layer->type()));
         return;
     }
 
     if (!value.isPrimitiveValue())
         return;
 
-    CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
+    const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
     if (primitiveValue.getValueID() == CSSValueContain)
         layer->setSizeType(Contain);
     else if (primitiveValue.getValueID() == CSSValueCover)
         layer->setSizeType(Cover);
     else
         layer->setSizeType(SizeLength);
 
     LengthSize b = FillLayer::initialFillSizeLength(layer->type());
 
     if (primitiveValue.getValueID() == CSSValueContain || primitiveValue.getValueID() == CSSValueCover) {
         layer->setSizeLength(b);
         return;
     }
 
     Length firstLength;
     Length secondLength;
 
     if (Pair* pair = primitiveValue.getPairValue()) {
-        firstLength = StyleBuilderConverter::convertLengthOrAuto(state, CSSValue(*pair->first()));
-        secondLength = StyleBuilderConverter::convertLengthOrAuto(state, CSSValue(*pair->second()));
+        firstLength = StyleBuilderConverter::convertLengthOrAuto(state, pair->first());
+        secondLength = StyleBuilderConverter::convertLengthOrAuto(state, pair->second());
     } else {
         firstLength = StyleBuilderConverter::convertLengthOrAuto(state, value);
         secondLength = Length();
     }
 
     b.setWidth(firstLength);
     b.setHeight(secondLength);
     layer->setSizeLength(b);
 }
 
 void CSSToStyleMap::mapFillXPosition(StyleResolverState& state, FillLayer* layer, const CSSValue& value)
 {
     if (value.isInitialValue()) {
         layer->setXPosition(FillLayer::initialFillXPosition(layer->type()));
         return;
     }
 
     if (!value.isPrimitiveValue())
         return;
 
-    CSSPrimitiveValue* primitiveValue = &toCSSPrimitiveValue(value);
-    Pair* pair = primitiveValue->getPairValue();
+    CSSPrimitiveValue primitiveValue = toCSSPrimitiveValue(value);
+    Pair* pair = primitiveValue.getPairValue();
     if (pair)
         primitiveValue = pair->second();
 
-    Length length = primitiveValue->convertToLength(state.cssToLengthConversionData());
+    Length length = primitiveValue.convertToLength(state.cssToLengthConversionData());
 
     layer->setXPosition(length);
     if (pair)
-        layer->setBackgroundXOrigin(*(pair->first()));
+        layer->setBackgroundXOrigin(pair->first());
 }
 
 void CSSToStyleMap::mapFillYPosition(StyleResolverState& state, FillLayer* layer, const CSSValue& value)
 {
     if (value.isInitialValue()) {
         layer->setYPosition(FillLayer::initialFillYPosition(layer->type()));
         return;
     }
 
     if (!value.isPrimitiveValue())
         return;
 
-    CSSPrimitiveValue* primitiveValue = &toCSSPrimitiveValue(value);
-    Pair* pair = primitiveValue->getPairValue();
+    CSSPrimitiveValue primitiveValue = toCSSPrimitiveValue(value);
+    Pair* pair = primitiveValue.getPairValue();
     if (pair)
         primitiveValue = pair->second();
 
-    Length length = primitiveValue->convertToLength(state.cssToLengthConversionData());
+    Length length = primitiveValue.convertToLength(state.cssToLengthConversionData());
 
     layer->setYPosition(length);
     if (pair)
-        layer->setBackgroundYOrigin(*(pair->first()));
+        layer->setBackgroundYOrigin(pair->first());
 }
 
 void CSSToStyleMap::mapFillMaskSourceType(StyleResolverState&, FillLayer* layer, const CSSValue& value)
 {
     EMaskSourceType type = FillLayer::initialFillMaskSourceType(layer->type());
     if (value.isInitialValue()) {
         layer->setMaskSourceType(type);
         return;
     }
 
@@ skipping 67 matching lines @@
     default:
         ASSERT_NOT_REACHED();
         return CSSAnimationData::initialFillMode();
     }
 }
 
 double CSSToStyleMap::mapAnimationIterationCount(const CSSValue& value)
 {
     if (value.isInitialValue())
         return CSSAnimationData::initialIterationCount();
-    CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
+    const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
     if (primitiveValue.getValueID() == CSSValueInfinite)
         return std::numeric_limits<double>::infinity();
     return primitiveValue.getFloatValue();
 }
 
 AtomicString CSSToStyleMap::mapAnimationName(const CSSValue& value)
 {
     if (value.isInitialValue())
         return CSSAnimationData::initialName();
-    CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
+    const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
     if (primitiveValue.getValueID() == CSSValueNone)
         return CSSAnimationData::initialName();
     return AtomicString(primitiveValue.getStringValue());
 }
 
 EAnimPlayState CSSToStyleMap::mapAnimationPlayState(const CSSValue& value)
 {
     if (value.isInitialValue())
         return CSSAnimationData::initialPlayState();
     if (toCSSPrimitiveValue(value).getValueID() == CSSValuePaused)
         return AnimPlayStatePaused;
     ASSERT(toCSSPrimitiveValue(value).getValueID() == CSSValueRunning);
     return AnimPlayStatePlaying;
 }
 
 CSSTransitionData::TransitionProperty CSSToStyleMap::mapAnimationProperty(const CSSValue& value)
 {
     if (value.isInitialValue())
         return CSSTransitionData::initialProperty();
-    CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
+    const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
     if (primitiveValue.isCustomIdent())
         return CSSTransitionData::TransitionProperty(primitiveValue.getStringValue());
     if (primitiveValue.getValueID() == CSSValueAll)
         return CSSTransitionData::TransitionProperty(CSSTransitionData::TransitionAll);
     if (primitiveValue.getValueID() == CSSValueNone)
         return CSSTransitionData::TransitionProperty(CSSTransitionData::TransitionNone);
     return CSSTransitionData::TransitionProperty(primitiveValue.getPropertyID());
 }
 
 PassRefPtr<TimingFunction> CSSToStyleMap::mapAnimationTimingFunction(const CSSValue& value, bool allowStepMiddle)
 {
     // FIXME: We should probably only call into this function with a valid
     // single timing function value which isn't initial or inherit. We can
     // currently get into here with initial since the parser expands unset
     // properties in shorthands to initial.
 
     if (value.isPrimitiveValue()) {
-        CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
+        const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
         switch (primitiveValue.getValueID()) {
         case CSSValueLinear:
             return LinearTimingFunction::shared();
         case CSSValueEase:
             return CubicBezierTimingFunction::preset(CubicBezierTimingFunction::Ease);
         case CSSValueEaseIn:
             return CubicBezierTimingFunction::preset(CubicBezierTimingFunction::EaseIn);
         case CSSValueEaseOut:
             return CubicBezierTimingFunction::preset(CubicBezierTimingFunction::EaseOut);
         case CSSValueEaseInOut:
@@ skipping 90 matching lines @@
 {
     if (!value || !value->isBorderImageSliceValue())
         return;
 
     // Retrieve the border image value.
     CSSBorderImageSliceValue* borderImageSlice = toCSSBorderImageSliceValue(value);
 
     // Set up a length box to represent our image slices.
     LengthBox box;
     Quad* slices = borderImageSlice->slices();
-    if (slices->top()->isPercentage())
-        box.m_top = Length(slices->top()->getDoubleValue(), Percent);
+    if (slices->top().isPercentage())
+        box.m_top = Length(slices->top().getDoubleValue(), Percent);
     else
-        box.m_top = Length(slices->top()->getIntValue(), Fixed);
-    if (slices->bottom()->isPercentage())
-        box.m_bottom = Length(slices->bottom()->getDoubleValue(), Percent);
+        box.m_top = Length(slices->top().getIntValue(), Fixed);
+    if (slices->bottom().isPercentage())
+        box.m_bottom = Length(slices->bottom().getDoubleValue(), Percent);
     else
-        box.m_bottom = Length(slices->bottom()->getIntValue(), Fixed);
-    if (slices->left()->isPercentage())
-        box.m_left = Length(slices->left()->getDoubleValue(), Percent);
+        box.m_bottom = Length(slices->bottom().getIntValue(), Fixed);
+    if (slices->left().isPercentage())
+        box.m_left = Length(slices->left().getDoubleValue(), Percent);
     else
-        box.m_left = Length(slices->left()->getIntValue(), Fixed);
-    if (slices->right()->isPercentage())
-        box.m_right = Length(slices->right()->getDoubleValue(), Percent);
+        box.m_left = Length(slices->left().getIntValue(), Fixed);
+    if (slices->right().isPercentage())
+        box.m_right = Length(slices->right().getDoubleValue(), Percent);
     else
-        box.m_right = Length(slices->right()->getIntValue(), Fixed);
+        box.m_right = Length(slices->right().getIntValue(), Fixed);
     image.setImageSlices(box);
 
     // Set our fill mode.
     image.setFill(borderImageSlice->m_fill);
 }
 
-static BorderImageLength toBorderImageLength(CSSPrimitiveValue& value, const CSSToLengthConversionData& conversionData)
+static BorderImageLength toBorderImageLength(CSSPrimitiveValue value, const CSSToLengthConversionData& conversionData)
 {
     if (value.isNumber())
         return value.getDoubleValue();
     if (value.isPercentage())
         return Length(value.getDoubleValue(), Percent);
     if (value.getValueID() != CSSValueAuto)
         return value.computeLength<Length>(conversionData);
     return Length(Auto);
 }
 
 BorderImageLengthBox CSSToStyleMap::mapNinePieceImageQuad(StyleResolverState& state, const NullableCSSValue& value)
 {
     if (!value || !value->isPrimitiveValue())
         return BorderImageLengthBox(Length(Auto));
 
-    Quad* slices = toCSSPrimitiveValue(value)->getQuadValue();
+    Quad* slices = toCSSPrimitiveValue(value).getQuadValue();
 
     // Set up a border image length box to represent our image slices.
     return BorderImageLengthBox(
-        toBorderImageLength(*slices->top(), state.cssToLengthConversionData()),
-        toBorderImageLength(*slices->right(), state.cssToLengthConversionData()),
-        toBorderImageLength(*slices->bottom(), state.cssToLengthConversionData()),
-        toBorderImageLength(*slices->left(), state.cssToLengthConversionData()));
+        toBorderImageLength(slices->top(), state.cssToLengthConversionData()),
+        toBorderImageLength(slices->right(), state.cssToLengthConversionData()),
+        toBorderImageLength(slices->bottom(), state.cssToLengthConversionData()),
+        toBorderImageLength(slices->left(), state.cssToLengthConversionData()));
 }
 
 void CSSToStyleMap::mapNinePieceImageRepeat(StyleResolverState&, const NullableCSSValue& value, NinePieceImage& image)
 {
     if (!value || !value->isPrimitiveValue())
         return;
 
-    CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
-    Pair* pair = primitiveValue->getPairValue();
-    if (!pair || !pair->first() || !pair->second())
+    const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
+    Pair* pair = primitiveValue.getPairValue();
+    if (!pair)
         return;
 
-    CSSValueID firstIdentifier = pair->first()->getValueID();
-    CSSValueID secondIdentifier = pair->second()->getValueID();
+    CSSValueID firstIdentifier = pair->first().getValueID();
+    CSSValueID secondIdentifier = pair->second().getValueID();
 
     ENinePieceImageRule horizontalRule;
     switch (firstIdentifier) {
     case CSSValueStretch:
         horizontalRule = StretchImageRule;
         break;
     case CSSValueRound:
         horizontalRule = RoundImageRule;
         break;
     case CSSValueSpace:
@@ skipping 17 matching lines @@
         verticalRule = SpaceImageRule;
         break;
     default: // CSSValueRepeat
         verticalRule = RepeatImageRule;
         break;
     }
     image.setVerticalRule(verticalRule);
 }
 
 };