Cleanup usage of CSSPropertyID and CSSValueID inside Blink.

Source/core/css/CSSGradientValue.cpp

 /*
  * Copyright (C) 2008 Apple Inc.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 394 matching lines @@
     if (value->isNumber())
         return value->getFloatValue() * zoomFactor;
 
     int edgeDistance = isHorizontal ? size.width() : size.height();
     if (value->isPercentage())
         return value->getFloatValue() / 100.f * edgeDistance;
 
     if (value->isCalculatedPercentageWithLength())
         return value->cssCalcValue()->toCalcValue(style, rootStyle, style->effectiveZoom())->evaluate(edgeDistance);
 
-    switch (value->getIdent()) {
+    switch (value->getValueID()) {
     case CSSValueTop:
         ASSERT(!isHorizontal);
         return 0;
     case CSSValueLeft:
         ASSERT(isHorizontal);
         return 0;
     case CSSValueBottom:
         ASSERT(!isHorizontal);
         return size.height();
     case CSSValueRight:
         ASSERT(isHorizontal);
         return size.width();
+    default:
+        break;
     }
 
     return value->computeLength<float>(style, rootStyle, zoomFactor);
 }
 
 FloatPoint CSSGradientValue::computeEndPoint(CSSPrimitiveValue* horizontal, CSSPrimitiveValue* vertical, RenderStyle* style, RenderStyle* rootStyle, const IntSize& size)
 {
     FloatPoint result;
 
     if (horizontal)
@@ skipping 110 matching lines @@
         if (m_repeating)
             result.appendLiteral("repeating-linear-gradient(");
         else
             result.appendLiteral("linear-gradient(");
 
         bool wroteSomething = false;
 
         if (m_angle && m_angle->computeDegrees() != 180) {
             result.append(m_angle->cssText());
             wroteSomething = true;
-        } else if ((m_firstX || m_firstY) && !(!m_firstX && m_firstY && m_firstY->getIdent() == CSSValueBottom)) {
+        } else if ((m_firstX || m_firstY) && !(!m_firstX && m_firstY && m_firstY->getValueID() == CSSValueBottom)) {
             result.appendLiteral("to ");
             if (m_firstX && m_firstY) {
                 result.append(m_firstX->cssText());
                 result.append(' ');
                 result.append(m_firstY->cssText());
             } else if (m_firstX)
                 result.append(m_firstX->cssText());
             else
                 result.append(m_firstY->cssText());
             wroteSomething = true;
@@ skipping 116 matching lines @@
             if (m_firstX)
                 secondPoint.setX(size.width() - firstPoint.x());
             if (m_firstY)
                 secondPoint.setY(size.height() - firstPoint.y());
             break;
         case CSSLinearGradient:
             if (m_firstX && m_firstY) {
                 // "Magic" corners, so the 50% line touches two corners.
                 float rise = size.width();
                 float run = size.height();
-                if (m_firstX && m_firstX->getIdent() == CSSValueLeft)
+                if (m_firstX && m_firstX->getValueID() == CSSValueLeft)
                     run *= -1;
-                if (m_firstY && m_firstY->getIdent() == CSSValueBottom)
+                if (m_firstY && m_firstY->getValueID() == CSSValueBottom)
                     rise *= -1;
                 // Compute angle, and flip it back to "bearing angle" degrees.
                 float angle = 90 - rad2deg(atan2(rise, run));
                 endPointsFromAngle(angle, size, firstPoint, secondPoint, m_gradientType);
             } else if (m_firstX || m_firstY) { 
                 secondPoint = computeEndPoint(m_firstX.get(), m_firstY.get(), renderer->style(), rootStyle, size);
                 if (m_firstX)
                     firstPoint.setX(size.width() - secondPoint.x());
                 if (m_firstY)
                     firstPoint.setY(size.height() - secondPoint.y());
@@ skipping 140 matching lines @@
     } else {
         if (m_repeating)
             result.appendLiteral("repeating-radial-gradient(");
         else
             result.appendLiteral("radial-gradient(");
 
         bool wroteSomething = false;
 
         // The only ambiguous case that needs an explicit shape to be provided
         // is when a sizing keyword is used (or all sizing is omitted).
-        if (m_shape && m_shape->getIdent() != CSSValueEllipse && (m_sizingBehavior || (!m_sizingBehavior && !m_endHorizontalSize))) {
+        if (m_shape && m_shape->getValueID() != CSSValueEllipse && (m_sizingBehavior || (!m_sizingBehavior && !m_endHorizontalSize))) {
             result.appendLiteral("circle");
             wroteSomething = true;
         }
 
-        if (m_sizingBehavior && m_sizingBehavior->getIdent() != CSSValueFarthestCorner) {
+        if (m_sizingBehavior && m_sizingBehavior->getValueID() != CSSValueFarthestCorner) {
             if (wroteSomething)
                 result.append(' ');
             result.append(m_sizingBehavior->cssText());
             wroteSomething = true;
         } else if (m_endHorizontalSize) {
             if (wroteSomething)
                 result.append(' ');
             result.append(m_endHorizontalSize->cssText());
             if (m_endVerticalSize) {
                 result.append(' ');
@@ skipping 159 matching lines @@
         float width = size.width();
         float height = size.height();
         secondRadius = resolveRadius(m_endHorizontalSize.get(), renderer->style(), rootStyle, &width);
         if (m_endVerticalSize)
             aspectRatio = secondRadius / resolveRadius(m_endVerticalSize.get(), renderer->style(), rootStyle, &height);
         else
             aspectRatio = 1;
     } else {
         enum GradientShape { Circle, Ellipse };
         GradientShape shape = Ellipse;
-        if ((m_shape && m_shape->getIdent() == CSSValueCircle)
+        if ((m_shape && m_shape->getValueID() == CSSValueCircle)
             || (!m_shape && !m_sizingBehavior && m_endHorizontalSize && !m_endVerticalSize))
             shape = Circle;
 
         enum GradientFill { ClosestSide, ClosestCorner, FarthestSide, FarthestCorner };
         GradientFill fill = FarthestCorner;
 
-        switch (m_sizingBehavior ? m_sizingBehavior->getIdent() : 0) {
+        switch (m_sizingBehavior ? m_sizingBehavior->getValueID() : 0) {
         case CSSValueContain:
         case CSSValueClosestSide:
             fill = ClosestSide;
             break;
         case CSSValueClosestCorner:
             fill = ClosestCorner;
             break;
         case CSSValueFarthestSide:
             fill = FarthestSide;
             break;
         case CSSValueCover:
         case CSSValueFarthestCorner:
             fill = FarthestCorner;
             break;
+        default:
+            break;
         }
 
         // Now compute the end radii based on the second point, shape and fill.
 
         // Horizontal
         switch (fill) {
         case ClosestSide: {
             float xDist = min(secondPoint.x(), size.width() - secondPoint.x());
             float yDist = min(secondPoint.y(), size.height() - secondPoint.y());
             if (shape == Circle) {
@@ skipping 120 matching lines @@
     CSSGradientValue::reportBaseClassMemoryUsage(memoryObjectInfo);
     info.addMember(m_firstRadius, "firstRadius");
     info.addMember(m_secondRadius, "secondRadius");
     info.addMember(m_shape, "shape");
     info.addMember(m_sizingBehavior, "sizingBehavior");
     info.addMember(m_endHorizontalSize, "endHorizontalSize");
     info.addMember(m_endVerticalSize, "endVerticalSize");
 }
 
 } // namespace WebCore