Split CSSPrimitiveValue into CSSPrimitiveValue and CSSIdentifierValue

third_party/WebKit/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 32 matching lines @@
 
 namespace blink {
 
 void CSSToStyleMap::mapFillAttachment(StyleResolverState&, FillLayer* layer, const CSSValue& value)
 {
     if (value.isInitialValue()) {
         layer->setAttachment(FillLayer::initialFillAttachment(layer->type()));
         return;
     }
 
-    if (!value.isPrimitiveValue())
+    if (!value.isIdentifierValue())
         return;
 
-    const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
-    switch (primitiveValue.getValueID()) {
+    const CSSIdentifierValue& identifierValue = toCSSIdentifierValue(value);
+    switch (identifierValue.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())
+    if (!value.isIdentifierValue())
         return;
 
-    const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
-    layer->setClip(primitiveValue.convertTo<EFillBox>());
+    const CSSIdentifierValue& identifierValue = toCSSIdentifierValue(value);
+    layer->setClip(identifierValue.convertTo<EFillBox>());
 }
 
 void CSSToStyleMap::mapFillComposite(StyleResolverState&, FillLayer* layer, const CSSValue& value)
 {
     if (value.isInitialValue()) {
         layer->setComposite(FillLayer::initialFillComposite(layer->type()));
         return;
     }
 
-    if (!value.isPrimitiveValue())
+    if (!value.isIdentifierValue())
         return;
 
-    const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
-    layer->setComposite(primitiveValue.convertTo<CompositeOperator>());
+    const CSSIdentifierValue& identifierValue = toCSSIdentifierValue(value);
+    layer->setComposite(identifierValue.convertTo<CompositeOperator>());
 }
 
 void CSSToStyleMap::mapFillBlendMode(StyleResolverState&, FillLayer* layer, const CSSValue& value)
 {
     if (value.isInitialValue()) {
         layer->setBlendMode(FillLayer::initialFillBlendMode(layer->type()));
         return;
     }
 
-    if (!value.isPrimitiveValue())
+    if (!value.isIdentifierValue())
         return;
 
-    const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
-    layer->setBlendMode(primitiveValue.convertTo<WebBlendMode>());
+    const CSSIdentifierValue& identifierValue = toCSSIdentifierValue(value);
+    layer->setBlendMode(identifierValue.convertTo<WebBlendMode>());
 }
 
 void CSSToStyleMap::mapFillOrigin(StyleResolverState&, FillLayer* layer, const CSSValue& value)
 {
     if (value.isInitialValue()) {
         layer->setOrigin(FillLayer::initialFillOrigin(layer->type()));
         return;
     }
 
-    if (!value.isPrimitiveValue())
+    if (!value.isIdentifierValue())
         return;
 
-    const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
-    layer->setOrigin(primitiveValue.convertTo<EFillBox>());
+    const CSSIdentifierValue& identifierValue = toCSSIdentifierValue(value);
+    layer->setOrigin(identifierValue.convertTo<EFillBox>());
 }
 
 
 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())
+    if (!value.isIdentifierValue())
         return;
 
-    const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
-    layer->setRepeatX(primitiveValue.convertTo<EFillRepeat>());
+    const CSSIdentifierValue& identifierValue = toCSSIdentifierValue(value);
+    layer->setRepeatX(identifierValue.convertTo<EFillRepeat>());
 }
 
 void CSSToStyleMap::mapFillRepeatY(StyleResolverState&, FillLayer* layer, const CSSValue& value)
 {
     if (value.isInitialValue()) {
         layer->setRepeatY(FillLayer::initialFillRepeatY(layer->type()));
         return;
     }
 
-    if (!value.isPrimitiveValue())
+    if (!value.isIdentifierValue())
         return;
 
-    const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
-    layer->setRepeatY(primitiveValue.convertTo<EFillRepeat>());
+    const CSSIdentifierValue& identifierValue = toCSSIdentifierValue(value);
+    layer->setRepeatY(identifierValue.convertTo<EFillRepeat>());
 }
 
 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() && !value.isValuePair())
+    if (!value.isIdentifierValue() && !value.isPrimitiveValue() && !value.isValuePair())
         return;
 
-    if (value.isPrimitiveValue() && toCSSPrimitiveValue(value).getValueID() == CSSValueContain)
+    if (value.isIdentifierValue() && toCSSIdentifierValue(value).getValueID() == CSSValueContain)
         layer->setSizeType(Contain);
-    else if (value.isPrimitiveValue() && toCSSPrimitiveValue(value).getValueID() == CSSValueCover)
+    else if (value.isIdentifierValue() && toCSSIdentifierValue(value).getValueID() == CSSValueCover)
         layer->setSizeType(Cover);
     else
         layer->setSizeType(SizeLength);
 
     LengthSize b = FillLayer::initialFillSizeLength(layer->type());
 
-    if (value.isPrimitiveValue() && (toCSSPrimitiveValue(value).getValueID() == CSSValueContain || toCSSPrimitiveValue(value).getValueID() == CSSValueCover)) {
+    if (value.isIdentifierValue() && (toCSSIdentifierValue(value).getValueID() == CSSValueContain || toCSSIdentifierValue(value).getValueID() == CSSValueCover)) {
         layer->setSizeLength(b);
         return;
     }
 
     Length firstLength;
     Length secondLength;
 
     if (value.isValuePair()) {
         const CSSValuePair& pair = toCSSValuePair(value);
         firstLength = StyleBuilderConverter::convertLengthOrAuto(state, pair.first());
         secondLength = StyleBuilderConverter::convertLengthOrAuto(state, pair.second());
     } else {
-        ASSERT(value.isPrimitiveValue());
+        DCHECK(value.isPrimitiveValue() || value.isIdentifierValue());
         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() && !value.isValuePair())
+    if (!value.isIdentifierValue() && !value.isPrimitiveValue() && !value.isValuePair())
         return;
 
     Length length;
     if (value.isValuePair())
         length = toCSSPrimitiveValue(toCSSValuePair(value).second()).convertToLength(state.cssToLengthConversionData());
     else
-        length = StyleBuilderConverter::convertPositionLength<CSSValueLeft, CSSValueRight>(state, toCSSPrimitiveValue(value));
+        length = StyleBuilderConverter::convertPositionLength<CSSValueLeft, CSSValueRight>(state, value);
 
     layer->setXPosition(length);
     if (value.isValuePair())
-        layer->setBackgroundXOrigin(toCSSPrimitiveValue(toCSSValuePair(value).first()).convertTo<BackgroundEdgeOrigin>());
+        layer->setBackgroundXOrigin(toCSSIdentifierValue(toCSSValuePair(value).first()).convertTo<BackgroundEdgeOrigin>());
 }
 
 void CSSToStyleMap::mapFillYPosition(StyleResolverState& state, FillLayer* layer, const CSSValue& value)
 {
     if (value.isInitialValue()) {
         layer->setYPosition(FillLayer::initialFillYPosition(layer->type()));
         return;
     }
 
-    if (!value.isPrimitiveValue() && !value.isValuePair())
+    if (!value.isIdentifierValue() && !value.isPrimitiveValue() && !value.isValuePair())
         return;
 
     Length length;
     if (value.isValuePair())
         length = toCSSPrimitiveValue(toCSSValuePair(value).second()).convertToLength(state.cssToLengthConversionData());
     else
-        length = StyleBuilderConverter::convertPositionLength<CSSValueTop, CSSValueBottom>(state, toCSSPrimitiveValue(value));
+        length = StyleBuilderConverter::convertPositionLength<CSSValueTop, CSSValueBottom>(state, value);
 
     layer->setYPosition(length);
     if (value.isValuePair())
-        layer->setBackgroundYOrigin(toCSSPrimitiveValue(toCSSValuePair(value).first()).convertTo<BackgroundEdgeOrigin>());
+        layer->setBackgroundYOrigin(toCSSIdentifierValue(toCSSValuePair(value).first()).convertTo<BackgroundEdgeOrigin>());
 }
 
 void CSSToStyleMap::mapFillMaskSourceType(StyleResolverState&, FillLayer* layer, const CSSValue& value)
 {
     EMaskSourceType type = FillLayer::initialFillMaskSourceType(layer->type());
     if (value.isInitialValue()) {
         layer->setMaskSourceType(type);
         return;
     }
 
-    if (!value.isPrimitiveValue())
+    if (!value.isIdentifierValue())
         return;
 
-    switch (toCSSPrimitiveValue(value).getValueID()) {
+    switch (toCSSIdentifierValue(value).getValueID()) {
     case CSSValueAlpha:
         type = MaskAlpha;
         break;
     case CSSValueLuminance:
         type = MaskLuminance;
         break;
     case CSSValueAuto:
         break;
     default:
         ASSERT_NOT_REACHED();
     }
 
     layer->setMaskSourceType(type);
 }
 
 double CSSToStyleMap::mapAnimationDelay(const CSSValue& value)
 {
     if (value.isInitialValue())
         return CSSTimingData::initialDelay();
     return toCSSPrimitiveValue(value).computeSeconds();
 }
 
 Timing::PlaybackDirection CSSToStyleMap::mapAnimationDirection(const CSSValue& value)
 {
     if (value.isInitialValue())
         return CSSAnimationData::initialDirection();
 
-    switch (toCSSPrimitiveValue(value).getValueID()) {
+    switch (toCSSIdentifierValue(value).getValueID()) {
     case CSSValueNormal:
         return Timing::PlaybackDirection::NORMAL;
     case CSSValueAlternate:
         return Timing::PlaybackDirection::ALTERNATE_NORMAL;
     case CSSValueReverse:
         return Timing::PlaybackDirection::REVERSE;
     case CSSValueAlternateReverse:
         return Timing::PlaybackDirection::ALTERNATE_REVERSE;
     default:
         ASSERT_NOT_REACHED();
         return CSSAnimationData::initialDirection();
     }
 }
 
 double CSSToStyleMap::mapAnimationDuration(const CSSValue& value)
 {
     if (value.isInitialValue())
         return CSSTimingData::initialDuration();
     return toCSSPrimitiveValue(value).computeSeconds();
 }
 
 Timing::FillMode CSSToStyleMap::mapAnimationFillMode(const CSSValue& value)
 {
     if (value.isInitialValue())
         return CSSAnimationData::initialFillMode();
 
-    switch (toCSSPrimitiveValue(value).getValueID()) {
+    switch (toCSSIdentifierValue(value).getValueID()) {
     case CSSValueNone:
         return Timing::FillMode::NONE;
     case CSSValueForwards:
         return Timing::FillMode::FORWARDS;
     case CSSValueBackwards:
         return Timing::FillMode::BACKWARDS;
     case CSSValueBoth:
         return Timing::FillMode::BOTH;
     default:
         ASSERT_NOT_REACHED();
         return CSSAnimationData::initialFillMode();
     }
 }
 
 double CSSToStyleMap::mapAnimationIterationCount(const CSSValue& value)
 {
     if (value.isInitialValue())
         return CSSAnimationData::initialIterationCount();
-    const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
-    if (primitiveValue.getValueID() == CSSValueInfinite)
+    if (value.isIdentifierValue() && toCSSIdentifierValue(value).getValueID() == CSSValueInfinite)
         return std::numeric_limits<double>::infinity();
-    return primitiveValue.getFloatValue();
+    return toCSSPrimitiveValue(value).getFloatValue();
 }
 
 AtomicString CSSToStyleMap::mapAnimationName(const CSSValue& value)
 {
     if (value.isInitialValue())
         return CSSAnimationData::initialName();
     if (value.isCustomIdentValue())
         return AtomicString(toCSSCustomIdentValue(value).value());
-    ASSERT(toCSSPrimitiveValue(value).getValueID() == CSSValueNone);
+    DCHECK_EQ(toCSSIdentifierValue(value).getValueID(), CSSValueNone);
     return CSSAnimationData::initialName();
 }
 
 EAnimPlayState CSSToStyleMap::mapAnimationPlayState(const CSSValue& value)
 {
     if (value.isInitialValue())
         return CSSAnimationData::initialPlayState();
-    if (toCSSPrimitiveValue(value).getValueID() == CSSValuePaused)
+    if (toCSSIdentifierValue(value).getValueID() == CSSValuePaused)
         return AnimPlayStatePaused;
-    ASSERT(toCSSPrimitiveValue(value).getValueID() == CSSValueRunning);
+    DCHECK_EQ(toCSSIdentifierValue(value).getValueID(), CSSValueRunning);
     return AnimPlayStatePlaying;
 }
 
 CSSTransitionData::TransitionProperty CSSToStyleMap::mapAnimationProperty(const CSSValue& value)
 {
     if (value.isInitialValue())
         return CSSTransitionData::initialProperty();
     if (value.isCustomIdentValue()) {
         const CSSCustomIdentValue& customIdentValue = toCSSCustomIdentValue(value);
         if (customIdentValue.isKnownPropertyID())
             return CSSTransitionData::TransitionProperty(customIdentValue.valueAsPropertyID());
         return CSSTransitionData::TransitionProperty(customIdentValue.value());
     }
-    ASSERT(toCSSPrimitiveValue(value).getValueID() == CSSValueNone);
+    DCHECK_EQ(toCSSIdentifierValue(value).getValueID(), CSSValueNone);
     return CSSTransitionData::TransitionProperty(CSSTransitionData::TransitionNone);
 }
 
 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()) {
-        const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
-        switch (primitiveValue.getValueID()) {
+    if (value.isIdentifierValue()) {
+        const CSSIdentifierValue& identifierValue = toCSSIdentifierValue(value);
+        switch (identifierValue.getValueID()) {
         case CSSValueLinear:
             return LinearTimingFunction::shared();
         case CSSValueEase:
             return CubicBezierTimingFunction::preset(CubicBezierTimingFunction::EaseType::EASE);
         case CSSValueEaseIn:
             return CubicBezierTimingFunction::preset(CubicBezierTimingFunction::EaseType::EASE_IN);
         case CSSValueEaseOut:
             return CubicBezierTimingFunction::preset(CubicBezierTimingFunction::EaseType::EASE_OUT);
         case CSSValueEaseInOut:
             return CubicBezierTimingFunction::preset(CubicBezierTimingFunction::EaseType::EASE_IN_OUT);
@@ skipping 96 matching lines @@
 {
     if (!value.isBorderImageSliceValue())
         return;
 
     // Retrieve the border image value.
     const CSSBorderImageSliceValue& borderImageSlice = toCSSBorderImageSliceValue(value);
 
     // Set up a length box to represent our image slices.
     LengthBox box;
     const CSSQuadValue& slices = borderImageSlice.slices();
-    box.m_top = convertBorderImageSliceSide(*slices.top());
-    box.m_bottom = convertBorderImageSliceSide(*slices.bottom());
-    box.m_left = convertBorderImageSliceSide(*slices.left());
-    box.m_right = convertBorderImageSliceSide(*slices.right());
+    box.m_top = convertBorderImageSliceSide(toCSSPrimitiveValue(*slices.top()));
+    box.m_bottom = convertBorderImageSliceSide(toCSSPrimitiveValue(*slices.bottom()));
+    box.m_left = convertBorderImageSliceSide(toCSSPrimitiveValue(*slices.left()));
+    box.m_right = convertBorderImageSliceSide(toCSSPrimitiveValue(*slices.right()));
     image.setImageSlices(box);
 
     // Set our fill mode.
     image.setFill(borderImageSlice.fill());
 }
 
-static BorderImageLength toBorderImageLength(CSSPrimitiveValue& value, const CSSToLengthConversionData& conversionData)
+static BorderImageLength toBorderImageLength(CSSValue& 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);
+    if (value.isPrimitiveValue()) {
+        const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(value);
+        if (primitiveValue.isNumber())
+            return primitiveValue.getDoubleValue();
+        if (primitiveValue.isPercentage())
+            return Length(primitiveValue.getDoubleValue(), Percent);
+        return primitiveValue.computeLength<Length>(conversionData);
+    }
+    DCHECK_EQ(toCSSIdentifierValue(value).getValueID(), CSSValueAuto);
     return Length(Auto);
 }
 
 BorderImageLengthBox CSSToStyleMap::mapNinePieceImageQuad(StyleResolverState& state, const CSSValue& value)
 {
     if (!value.isQuadValue())
         return BorderImageLengthBox(Length(Auto));
 
     const CSSQuadValue& slices = toCSSQuadValue(value);
 
     // 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()));
 }
 
 void CSSToStyleMap::mapNinePieceImageRepeat(StyleResolverState&, const CSSValue& value, NinePieceImage& image)
 {
     if (!value.isValuePair())
         return;
 
     const CSSValuePair& pair = toCSSValuePair(value);
-    CSSValueID firstIdentifier = toCSSPrimitiveValue(pair.first()).getValueID();
-    CSSValueID secondIdentifier = toCSSPrimitiveValue(pair.second()).getValueID();
+    CSSValueID firstIdentifier = toCSSIdentifierValue(pair.first()).getValueID();
+    CSSValueID secondIdentifier = toCSSIdentifierValue(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);
 }
 
 } // namespace blink