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 33 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));
+                                                          CSSValueRight>(state,
+                                                                         value);
 
   layer->setXPosition(length);
   if (value.isValuePair())
     layer->setBackgroundXOrigin(
-        toCSSPrimitiveValue(toCSSValuePair(value).first())
+        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));
+        state, value);
 
   layer->setYPosition(length);
   if (value.isValuePair())
     layer->setBackgroundYOrigin(
-        toCSSPrimitiveValue(toCSSValuePair(value).first())
+        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(
@@ skipping 122 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,
+    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