Cleanup usage of CSSPropertyID and CSSValueID inside Blink.

Source/core/css/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 54 matching lines @@
 {
     if (value->isInitialValue()) {
         layer->setAttachment(FillLayer::initialFillAttachment(layer->type()));
         return;
     }
 
     if (!value->isPrimitiveValue())
         return;
 
     CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
-    switch (primitiveValue->getIdent()) {
+    switch (primitiveValue->getValueID()) {
     case CSSValueFixed:
         layer->setAttachment(FixedBackgroundAttachment);
         break;
     case CSSValueScroll:
         layer->setAttachment(ScrollBackgroundAttachment);
         break;
     case CSSValueLocal:
         layer->setAttachment(LocalBackgroundAttachment);
         break;
     default:
@@ skipping 97 matching lines @@
 }
 
 void CSSToStyleMap::mapFillSize(CSSPropertyID, FillLayer* layer, CSSValue* value)
 {
     if (!value->isPrimitiveValue()) {
         layer->setSizeType(SizeNone);
         return;
     }
 
     CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
-    if (primitiveValue->getIdent() == CSSValueContain)
+    if (primitiveValue->getValueID() == CSSValueContain)
         layer->setSizeType(Contain);
-    else if (primitiveValue->getIdent() == CSSValueCover)
+    else if (primitiveValue->getValueID() == CSSValueCover)
         layer->setSizeType(Cover);
     else
         layer->setSizeType(SizeLength);
 
     LengthSize b = FillLayer::initialFillSizeLength(layer->type());
 
-    if (value->isInitialValue() || primitiveValue->getIdent() == CSSValueContain || primitiveValue->getIdent() == CSSValueCover) {
+    if (value->isInitialValue() || primitiveValue->getValueID() == CSSValueContain || primitiveValue->getValueID() == CSSValueCover) {
         layer->setSizeLength(b);
         return;
     }
 
     float zoomFactor = style()->effectiveZoom();
 
     Length firstLength;
     Length secondLength;
 
     if (Pair* pair = primitiveValue->getPairValue()) {
@@ skipping 102 matching lines @@
 {
     if (value->isInitialValue()) {
         layer->setDirection(CSSAnimationData::initialAnimationDirection());
         return;
     }
 
     if (!value->isPrimitiveValue())
         return;
 
     CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
-    switch (primitiveValue->getIdent()) {
+    switch (primitiveValue->getValueID()) {
     case CSSValueNormal:
         layer->setDirection(CSSAnimationData::AnimationDirectionNormal);
         break;
     case CSSValueAlternate:
         layer->setDirection(CSSAnimationData::AnimationDirectionAlternate);
         break;
     case CSSValueReverse:
         layer->setDirection(CSSAnimationData::AnimationDirectionReverse);
         break;
     case CSSValueAlternateReverse:
         layer->setDirection(CSSAnimationData::AnimationDirectionAlternateReverse);
         break;
+    default:
+        break;
     }
 }
 
 void CSSToStyleMap::mapAnimationDuration(CSSAnimationData* animation, CSSValue* value)
 {
     if (value->isInitialValue()) {
         animation->setDuration(CSSAnimationData::initialAnimationDuration());
         return;
     }
 
     if (!value->isPrimitiveValue())
         return;
 
     CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
     animation->setDuration(primitiveValue->computeTime<double, CSSPrimitiveValue::Seconds>());
 }
 
 void CSSToStyleMap::mapAnimationFillMode(CSSAnimationData* layer, CSSValue* value)
 {
     if (value->isInitialValue()) {
         layer->setFillMode(CSSAnimationData::initialAnimationFillMode());
         return;
     }
 
     if (!value->isPrimitiveValue())
         return;
 
     CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
-    switch (primitiveValue->getIdent()) {
+    switch (primitiveValue->getValueID()) {
     case CSSValueNone:
         layer->setFillMode(AnimationFillModeNone);
         break;
     case CSSValueForwards:
         layer->setFillMode(AnimationFillModeForwards);
         break;
     case CSSValueBackwards:
         layer->setFillMode(AnimationFillModeBackwards);
         break;
     case CSSValueBoth:
         layer->setFillMode(AnimationFillModeBoth);
         break;
+    default:
+        break;
     }
 }
 
 void CSSToStyleMap::mapAnimationIterationCount(CSSAnimationData* animation, CSSValue* value)
 {
     if (value->isInitialValue()) {
         animation->setIterationCount(CSSAnimationData::initialAnimationIterationCount());
         return;
     }
 
     if (!value->isPrimitiveValue())
         return;
 
     CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
-    if (primitiveValue->getIdent() == CSSValueInfinite)
+    if (primitiveValue->getValueID() == CSSValueInfinite)
         animation->setIterationCount(CSSAnimationData::IterationCountInfinite);
     else
         animation->setIterationCount(primitiveValue->getFloatValue());
 }
 
 void CSSToStyleMap::mapAnimationName(CSSAnimationData* layer, CSSValue* value)
 {
     if (value->isInitialValue()) {
         layer->setName(CSSAnimationData::initialAnimationName());
         return;
     }
 
     if (!value->isPrimitiveValue())
         return;
 
     CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
-    if (primitiveValue->getIdent() == CSSValueNone)
+    if (primitiveValue->getValueID() == CSSValueNone)
         layer->setIsNoneAnimation(true);
     else
         layer->setName(primitiveValue->getStringValue());
 }
 
 void CSSToStyleMap::mapAnimationPlayState(CSSAnimationData* layer, CSSValue* value)
 {
     if (value->isInitialValue()) {
         layer->setPlayState(CSSAnimationData::initialAnimationPlayState());
         return;
     }
 
     if (!value->isPrimitiveValue())
         return;
 
     CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
-    EAnimPlayState playState = (primitiveValue->getIdent() == CSSValuePaused) ? AnimPlayStatePaused : AnimPlayStatePlaying;
+    EAnimPlayState playState = (primitiveValue->getValueID() == CSSValuePaused) ? AnimPlayStatePaused : AnimPlayStatePlaying;
     layer->setPlayState(playState);
 }
 
 void CSSToStyleMap::mapAnimationProperty(CSSAnimationData* animation, CSSValue* value)
 {
     if (value->isInitialValue()) {
         animation->setAnimationMode(CSSAnimationData::AnimateAll);
         animation->setProperty(CSSPropertyInvalid);
         return;
     }
 
     if (!value->isPrimitiveValue())
         return;
 
     CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
-    if (primitiveValue->getIdent() == CSSValueAll) {
+    if (primitiveValue->getValueID() == CSSValueAll) {
         animation->setAnimationMode(CSSAnimationData::AnimateAll);
         animation->setProperty(CSSPropertyInvalid);
-    } else if (primitiveValue->getIdent() == CSSValueNone) {
+    } else if (primitiveValue->getValueID() == CSSValueNone) {
         animation->setAnimationMode(CSSAnimationData::AnimateNone);
         animation->setProperty(CSSPropertyInvalid);
     } else {
         animation->setAnimationMode(CSSAnimationData::AnimateSingleProperty);
-        animation->setProperty(static_cast<CSSPropertyID>(primitiveValue->getIdent()));
+        animation->setProperty(primitiveValue->getPropertyID());
     }
 }
 
 void CSSToStyleMap::mapAnimationTimingFunction(CSSAnimationData* animation, CSSValue* value)
 {
     if (value->isInitialValue()) {
         animation->setTimingFunction(CSSAnimationData::initialAnimationTimingFunction());
         return;
     }
 
     if (value->isPrimitiveValue()) {
         CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
-        switch (primitiveValue->getIdent()) {
+        switch (primitiveValue->getValueID()) {
         case CSSValueLinear:
             animation->setTimingFunction(LinearTimingFunction::create());
             break;
         case CSSValueEase:
             animation->setTimingFunction(CubicBezierTimingFunction::preset(CubicBezierTimingFunction::Ease));
             break;
         case CSSValueEaseIn:
             animation->setTimingFunction(CubicBezierTimingFunction::preset(CubicBezierTimingFunction::EaseIn));
             break;
         case CSSValueEaseOut:
             animation->setTimingFunction(CubicBezierTimingFunction::preset(CubicBezierTimingFunction::EaseOut));
             break;
         case CSSValueEaseInOut:
             animation->setTimingFunction(CubicBezierTimingFunction::preset(CubicBezierTimingFunction::EaseInOut));
             break;
         case CSSValueStepStart:
             animation->setTimingFunction(StepsTimingFunction::create(1, true));
             break;
         case CSSValueStepEnd:
             animation->setTimingFunction(StepsTimingFunction::create(1, false));
             break;
+        default:
+            break;
         }
         return;
     }
 
     if (value->isCubicBezierTimingFunctionValue()) {
         CSSCubicBezierTimingFunctionValue* cubicTimingFunction = static_cast<CSSCubicBezierTimingFunctionValue*>(value);
         animation->setTimingFunction(CubicBezierTimingFunction::create(cubicTimingFunction->x1(), cubicTimingFunction->y1(), cubicTimingFunction->x2(), cubicTimingFunction->y2()));
     } else if (value->isStepsTimingFunctionValue()) {
         CSSStepsTimingFunctionValue* stepsTimingFunction = static_cast<CSSStepsTimingFunctionValue*>(value);
         animation->setTimingFunction(StepsTimingFunction::create(stepsTimingFunction->numberOfSteps(), stepsTimingFunction->stepAtStart()));
@@ skipping 104 matching lines @@
     // Retrieve the primitive value.
     CSSPrimitiveValue* borderWidths = toCSSPrimitiveValue(value);
 
     // Set up a length box to represent our image slices.
     LengthBox box; // Defaults to 'auto' so we don't have to handle that explicitly below.
     Quad* slices = borderWidths->getQuadValue();
     if (slices->top()->isNumber())
         box.m_top = Length(slices->top()->getIntValue(), Relative);
     else if (slices->top()->isPercentage())
         box.m_top = Length(slices->top()->getDoubleValue(CSSPrimitiveValue::CSS_PERCENTAGE), Percent);
-    else if (slices->top()->getIdent() != CSSValueAuto)
+    else if (slices->top()->getValueID() != CSSValueAuto)
         box.m_top = slices->top()->computeLength<Length>(style(), rootElementStyle(), zoom);
 
     if (slices->right()->isNumber())
         box.m_right = Length(slices->right()->getIntValue(), Relative);
     else if (slices->right()->isPercentage())
         box.m_right = Length(slices->right()->getDoubleValue(CSSPrimitiveValue::CSS_PERCENTAGE), Percent);
-    else if (slices->right()->getIdent() != CSSValueAuto)
+    else if (slices->right()->getValueID() != CSSValueAuto)
         box.m_right = slices->right()->computeLength<Length>(style(), rootElementStyle(), zoom);
 
     if (slices->bottom()->isNumber())
         box.m_bottom = Length(slices->bottom()->getIntValue(), Relative);
     else if (slices->bottom()->isPercentage())
         box.m_bottom = Length(slices->bottom()->getDoubleValue(CSSPrimitiveValue::CSS_PERCENTAGE), Percent);
-    else if (slices->bottom()->getIdent() != CSSValueAuto)
+    else if (slices->bottom()->getValueID() != CSSValueAuto)
         box.m_bottom = slices->bottom()->computeLength<Length>(style(), rootElementStyle(), zoom);
 
     if (slices->left()->isNumber())
         box.m_left = Length(slices->left()->getIntValue(), Relative);
     else if (slices->left()->isPercentage())
         box.m_left = Length(slices->left()->getDoubleValue(CSSPrimitiveValue::CSS_PERCENTAGE), Percent);
-    else if (slices->left()->getIdent() != CSSValueAuto)
+    else if (slices->left()->getValueID() != CSSValueAuto)
         box.m_left = slices->left()->computeLength<Length>(style(), rootElementStyle(), zoom);
 
     return box;
 }
 
 void CSSToStyleMap::mapNinePieceImageRepeat(CSSValue* value, NinePieceImage& image)
 {
     if (!value || !value->isPrimitiveValue())
         return;
 
     CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
     Pair* pair = primitiveValue->getPairValue();
     if (!pair || !pair->first() || !pair->second())
         return;
 
-    int firstIdentifier = pair->first()->getIdent();
-    int secondIdentifier = pair->second()->getIdent();
+    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);
 }
 
 };