CSSValue Immediates: Remove redundant isTaggedPtr() checks

Source/core/css/CSSPrimitiveValueMappings.h

 /*
  * Copyright (C) 2007 Alexey Proskuryakov <ap@nypop.com>.
  * Copyright (C) 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (C) 2009 Jeff Schiller <codedread@gmail.com>
  * Copyright (C) Research In Motion Limited 2010. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
@@ skipping 99 matching lines @@
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineClampValue i)
     : CSSValue(PrimitiveClass)
 {
     m_primitiveUnitType = i.isPercentage() ? CSS_PERCENTAGE : CSS_NUMBER;
     m_value.num = static_cast<double>(i.value());
 }
 
 template<> inline CSSPrimitiveValue::operator LineClampValue() const
 {
-    if (type() == CSS_NUMBER)
-        return LineClampValue(clampTo<int>(value().num), LineClampLineCount);
+    UnitType unitType = type();
+    if (unitType == CSS_NUMBER)
+        return LineClampValue(clampTo<int>(numValue()), LineClampLineCount);
 
-    if (type() == CSS_PERCENTAGE)
-        return LineClampValue(clampTo<int>(value().num), LineClampPercentage);
+    if (unitType == CSS_PERCENTAGE)
+        return LineClampValue(clampTo<int>(numValue()), LineClampPercentage);
 
     ASSERT_NOT_REACHED();
     return LineClampValue();
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(CSSReflectionDirection e)
     : CSSValue(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case ReflectionAbove:
         m_value.valueID = CSSValueAbove;
         break;
     case ReflectionBelow:
         m_value.valueID = CSSValueBelow;
         break;
     case ReflectionLeft:
         m_value.valueID = CSSValueLeft;
         break;
     case ReflectionRight:
         m_value.valueID = CSSValueRight;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator CSSReflectionDirection() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueAbove:
         return ReflectionAbove;
     case CSSValueBelow:
         return ReflectionBelow;
     case CSSValueLeft:
         return ReflectionLeft;
     case CSSValueRight:
         return ReflectionRight;
     default:
         break;
@@ skipping 13 matching lines @@
         break;
     case ColumnFillBalance:
         m_value.valueID = CSSValueBalance;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator ColumnFill() const
 {
     if (type() == CSS_VALUE_ID) {
-        if (value().valueID == CSSValueBalance)
+        CSSValueID valueID = valueIDValue();
+        if (valueID == CSSValueBalance)
             return ColumnFillBalance;
-        if (value().valueID == CSSValueAuto)
+        if (valueID == CSSValueAuto)
             return ColumnFillAuto;
     }
     ASSERT_NOT_REACHED();
     return ColumnFillBalance;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ColumnSpan columnSpan)
     : CSSValue(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (columnSpan) {
     case ColumnSpanAll:
         m_value.valueID = CSSValueAll;
         break;
     case ColumnSpanNone:
         m_value.valueID = CSSValueNone;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator ColumnSpan() const
 {
     // Map 1 to none for compatibility reasons.
-    if (type() == CSS_NUMBER && value().num == 1)
+    if (type() == CSS_NUMBER && numValue() == 1)
         return ColumnSpanNone;
 
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueAll:
         return ColumnSpanAll;
     case CSSValueNone:
         return ColumnSpanNone;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return ColumnSpanNone;
@@ skipping 10 matching lines @@
         break;
     case PrintColorAdjustEconomy:
         m_value.valueID = CSSValueEconomy;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator PrintColorAdjust() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueEconomy:
         return PrintColorAdjustEconomy;
     case CSSValueExact:
         return PrintColorAdjustExact;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return PrintColorAdjustEconomy;
@@ skipping 34 matching lines @@
         break;
     case DOUBLE:
         m_value.valueID = CSSValueDouble;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EBorderStyle() const
 {
     ASSERT(isValueID());
-    if (value().valueID == CSSValueAuto) // Valid for CSS outline-style
+    if (valueIDValue() == CSSValueAuto) // Valid for CSS outline-style
         return DOTTED;
-    return (EBorderStyle)(value().valueID - CSSValueNone);
+    return (EBorderStyle)(valueIDValue() - CSSValueNone);
 }
 
 template<> inline CSSPrimitiveValue::operator OutlineIsAuto() const
 {
-    if (value().valueID == CSSValueAuto)
+    if (valueIDValue() == CSSValueAuto)
         return AUTO_ON;
     return AUTO_OFF;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(CompositeOperator e)
     : CSSValue(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case CompositeClear:
@@ skipping 34 matching lines @@
         break;
     default:
         ASSERT_NOT_REACHED();
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator CompositeOperator() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueClear:
         return CompositeClear;
     case CSSValueCopy:
         return CompositeCopy;
     case CSSValueSourceOver:
         return CompositeSourceOver;
     case CSSValueSourceIn:
         return CompositeSourceIn;
     case CSSValueSourceOut:
         return CompositeSourceOut;
@@ skipping 179 matching lines @@
         break;
     case CapsLockIndicatorPart:
         m_value.valueID = CSSValueCapsLockIndicator;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator ControlPart() const
 {
     ASSERT(isValueID());
-    if (value().valueID == CSSValueNone)
+    if (valueIDValue() == CSSValueNone)
         return NoControlPart;
-    return ControlPart(value().valueID - CSSValueCheckbox + 1);
+    return ControlPart(valueIDValue() - CSSValueCheckbox + 1);
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBackfaceVisibility e)
     : CSSValue(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case BackfaceVisibilityVisible:
         m_value.valueID = CSSValueVisible;
         break;
     case BackfaceVisibilityHidden:
         m_value.valueID = CSSValueHidden;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EBackfaceVisibility() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueVisible:
         return BackfaceVisibilityVisible;
     case CSSValueHidden:
         return BackfaceVisibilityHidden;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return BackfaceVisibilityHidden;
@@ skipping 13 matching lines @@
         break;
     case FixedBackgroundAttachment:
         m_value.valueID = CSSValueFixed;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EFillAttachment() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueScroll:
         return ScrollBackgroundAttachment;
     case CSSValueLocal:
         return LocalBackgroundAttachment;
     case CSSValueFixed:
         return FixedBackgroundAttachment;
     default:
         break;
     }
 
@@ skipping 17 matching lines @@
         break;
     case TextFillBox:
         m_value.valueID = CSSValueText;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EFillBox() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueBorder:
     case CSSValueBorderBox:
         return BorderFillBox;
     case CSSValuePadding:
     case CSSValuePaddingBox:
         return PaddingFillBox;
     case CSSValueContent:
     case CSSValueContentBox:
         return ContentFillBox;
     case CSSValueText:
@@ skipping 23 matching lines @@
         break;
     case SpaceFill:
         m_value.valueID = CSSValueSpace;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EFillRepeat() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueRepeat:
         return RepeatFill;
     case CSSValueNoRepeat:
         return NoRepeatFill;
     case CSSValueRound:
         return RoundFill;
     case CSSValueSpace:
         return SpaceFill;
     default:
         break;
@@ skipping 19 matching lines @@
         break;
     case Justify:
         m_value.valueID = CSSValueJustify;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EBoxPack() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueStart:
         return Start;
     case CSSValueEnd:
         return End;
     case CSSValueCenter:
         return Center;
     case CSSValueJustify:
         return Justify;
     default:
         break;
@@ skipping 22 matching lines @@
         break;
     case BBASELINE:
         m_value.valueID = CSSValueBaseline;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EBoxAlignment() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueStretch:
         return BSTRETCH;
     case CSSValueStart:
         return BSTART;
     case CSSValueEnd:
         return BEND;
     case CSSValueCenter:
         return BCENTER;
     case CSSValueBaseline:
         return BBASELINE;
@@ skipping 15 matching lines @@
         break;
     case DCLONE:
         m_value.valueID = CSSValueClone;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EBoxDecorationBreak() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueSlice:
         return DSLICE;
     case CSSValueClone:
         return DCLONE;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return DSLICE;
@@ skipping 15 matching lines @@
         break;
     case LeftEdge:
         m_value.valueID = CSSValueLeft;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator BackgroundEdgeOrigin() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueTop:
         return TopEdge;
     case CSSValueRight:
         return RightEdge;
     case CSSValueBottom:
         return BottomEdge;
     case CSSValueLeft:
         return LeftEdge;
     default:
         break;
@@ skipping 13 matching lines @@
         break;
     case CONTENT_BOX:
         m_value.valueID = CSSValueContentBox;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EBoxSizing() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueBorderBox:
         return BORDER_BOX;
     case CSSValueContentBox:
         return CONTENT_BOX;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return BORDER_BOX;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxDirection e)
     : CSSValue(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case BNORMAL:
         m_value.valueID = CSSValueNormal;
         break;
     case BREVERSE:
         m_value.valueID = CSSValueReverse;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EBoxDirection() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueNormal:
         return BNORMAL;
     case CSSValueReverse:
         return BREVERSE;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return BNORMAL;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxLines e)
     : CSSValue(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case SINGLE:
         m_value.valueID = CSSValueSingle;
         break;
     case MULTIPLE:
         m_value.valueID = CSSValueMultiple;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EBoxLines() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueSingle:
         return SINGLE;
     case CSSValueMultiple:
         return MULTIPLE;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return SINGLE;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxOrient e)
     : CSSValue(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case HORIZONTAL:
         m_value.valueID = CSSValueHorizontal;
         break;
     case VERTICAL:
         m_value.valueID = CSSValueVertical;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EBoxOrient() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueHorizontal:
     case CSSValueInlineAxis:
         return HORIZONTAL;
     case CSSValueVertical:
     case CSSValueBlockAxis:
         return VERTICAL;
     default:
         break;
     }
 
@@ skipping 17 matching lines @@
         break;
     case CAPBOTTOM:
         m_value.valueID = CSSValueBottom;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator ECaptionSide() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueLeft:
         return CAPLEFT;
     case CSSValueRight:
         return CAPRIGHT;
     case CSSValueTop:
         return CAPTOP;
     case CSSValueBottom:
         return CAPBOTTOM;
     default:
         break;
@@ skipping 19 matching lines @@
         break;
     case CBOTH:
         m_value.valueID = CSSValueBoth;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EClear() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueNone:
         return CNONE;
     case CSSValueLeft:
         return CLEFT;
     case CSSValueRight:
         return CRIGHT;
     case CSSValueBoth:
         return CBOTH;
     default:
         break;
@@ skipping 115 matching lines @@
         break;
     case CURSOR_WEBKIT_GRABBING:
         m_value.valueID = CSSValueWebkitGrabbing;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator ECursor() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueCopy:
         return CURSOR_COPY;
     case CSSValueWebkitZoomIn:
         return CURSOR_ZOOM_IN;
     case CSSValueWebkitZoomOut:
         return CURSOR_ZOOM_OUT;
     case CSSValueNone:
         return CURSOR_NONE;
     default:
-        return static_cast<ECursor>(value().valueID - CSSValueAuto);
+        return static_cast<ECursor>(valueIDValue() - CSSValueAuto);
     }
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EDisplay e)
     : CSSValue(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case INLINE:
         m_value.valueID = CSSValueInline;
@@ skipping 57 matching lines @@
         break;
     case NONE:
         m_value.valueID = CSSValueNone;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EDisplay() const
 {
     ASSERT(isValueID());
-    if (value().valueID == CSSValueNone)
+    if (valueIDValue() == CSSValueNone)
         return NONE;
 
-    if (value().valueID == CSSValueWebkitFlex)
+    if (valueIDValue() == CSSValueWebkitFlex)
         return FLEX;
-    if (value().valueID == CSSValueWebkitInlineFlex)
+    if (valueIDValue() == CSSValueWebkitInlineFlex)
         return INLINE_FLEX;
 
-    EDisplay display = static_cast<EDisplay>(value().valueID - CSSValueInline);
+    EDisplay display = static_cast<EDisplay>(valueIDValue() - CSSValueInline);
     ASSERT(display >= INLINE && display <= NONE);
     return display;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EEmptyCell e)
     : CSSValue(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case SHOW:
         m_value.valueID = CSSValueShow;
         break;
     case HIDE:
         m_value.valueID = CSSValueHide;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EEmptyCell() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueShow:
         return SHOW;
     case CSSValueHide:
         return HIDE;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return SHOW;
@@ skipping 15 matching lines @@
         break;
     case FlowColumnReverse:
         m_value.valueID = CSSValueColumnReverse;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EFlexDirection() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueRow:
         return FlowRow;
     case CSSValueRowReverse:
         return FlowRowReverse;
     case CSSValueColumn:
         return FlowColumn;
     case CSSValueColumnReverse:
         return FlowColumnReverse;
     default:
         break;
@@ skipping 16 matching lines @@
         break;
     case FlexWrapReverse:
         m_value.valueID = CSSValueWrapReverse;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EFlexWrap() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueNowrap:
         return FlexNoWrap;
     case CSSValueWrap:
         return FlexWrap;
     case CSSValueWrapReverse:
         return FlexWrapReverse;
     default:
         break;
     }
 
@@ skipping 14 matching lines @@
         break;
     case RightFloat:
         m_value.valueID = CSSValueRight;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EFloat() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueLeft:
         return LeftFloat;
     case CSSValueRight:
         return RightFloat;
     case CSSValueNone:
         return NoFloat;
     default:
         break;
     }
 
@@ skipping 20 matching lines @@
         break;
     case LineBreakAfterWhiteSpace:
         m_value.valueID = CSSValueAfterWhiteSpace;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator LineBreak() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueAuto:
         return LineBreakAuto;
     case CSSValueLoose:
         return LineBreakLoose;
     case CSSValueNormal:
         return LineBreakNormal;
     case CSSValueStrict:
         return LineBreakStrict;
     case CSSValueAfterWhiteSpace:
         return LineBreakAfterWhiteSpace;
@@ skipping 15 matching lines @@
         break;
     case INSIDE:
         m_value.valueID = CSSValueInside;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EListStylePosition() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueOutside:
         return OUTSIDE;
     case CSSValueInside:
         return INSIDE;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return OUTSIDE;
@@ skipping 171 matching lines @@
         break;
     case Urdu:
         m_value.valueID = CSSValueUrdu;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EListStyleType() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueNone:
         return NoneListStyle;
     default:
-        return static_cast<EListStyleType>(value().valueID - CSSValueDisc);
+        return static_cast<EListStyleType>(valueIDValue() - CSSValueDisc);
     }
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EMarginCollapse e)
     : CSSValue(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case MCOLLAPSE:
         m_value.valueID = CSSValueCollapse;
         break;
     case MSEPARATE:
         m_value.valueID = CSSValueSeparate;
         break;
     case MDISCARD:
         m_value.valueID = CSSValueDiscard;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EMarginCollapse() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueCollapse:
         return MCOLLAPSE;
     case CSSValueSeparate:
         return MSEPARATE;
     case CSSValueDiscard:
         return MDISCARD;
     default:
         break;
     }
 
@@ skipping 26 matching lines @@
         break;
     case OPAGEDY:
         m_value.valueID = CSSValueWebkitPagedY;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EOverflow() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueVisible:
         return OVISIBLE;
     case CSSValueHidden:
         return OHIDDEN;
     case CSSValueScroll:
         return OSCROLL;
     case CSSValueAuto:
         return OAUTO;
     case CSSValueOverlay:
         return OOVERLAY;
@@ skipping 22 matching lines @@
         break;
     case PBAVOID:
         m_value.valueID = CSSValueAvoid;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EPageBreak() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueAuto:
         return PBAUTO;
     case CSSValueLeft:
     case CSSValueRight:
     case CSSValueAlways:
         return PBALWAYS; // CSS2.1: "Conforming user agents may map left/right to always."
     case CSSValueAvoid:
         return PBAVOID;
     default:
         break;
@@ skipping 22 matching lines @@
         break;
     case StickyPosition:
         m_value.valueID = CSSValueSticky;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EPosition() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueStatic:
         return StaticPosition;
     case CSSValueRelative:
         return RelativePosition;
     case CSSValueAbsolute:
         return AbsolutePosition;
     case CSSValueFixed:
         return FixedPosition;
     case CSSValueSticky:
         return StickyPosition;
@@ skipping 21 matching lines @@
         break;
     case RESIZE_NONE:
         m_value.valueID = CSSValueNone;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EResize() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueBoth:
         return RESIZE_BOTH;
     case CSSValueHorizontal:
         return RESIZE_HORIZONTAL;
     case CSSValueVertical:
         return RESIZE_VERTICAL;
     case CSSValueAuto:
         ASSERT_NOT_REACHED(); // Depends on settings, thus should be handled by the caller.
         return RESIZE_NONE;
     case CSSValueNone:
@@ skipping 16 matching lines @@
         break;
     case TFIXED:
         m_value.valueID = CSSValueFixed;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator ETableLayout() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueFixed:
         return TFIXED;
     case CSSValueAuto:
         return TAUTO;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return TAUTO;
@@ skipping 30 matching lines @@
         break;
     case WEBKIT_CENTER:
         m_value.valueID = CSSValueWebkitCenter;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator ETextAlign() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueWebkitAuto: // Legacy -webkit-auto. Eqiuvalent to start.
     case CSSValueStart:
         return TASTART;
     case CSSValueEnd:
         return TAEND;
     default:
-        return static_cast<ETextAlign>(value().valueID - CSSValueLeft);
+        return static_cast<ETextAlign>(valueIDValue() - CSSValueLeft);
     }
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextAlignLast e)
     : CSSValue(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case TextAlignLastStart:
         m_value.valueID = CSSValueStart;
@@ skipping 15 matching lines @@
         break;
     case TextAlignLastAuto:
         m_value.valueID = CSSValueAuto;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator TextAlignLast() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueAuto:
         return TextAlignLastAuto;
     case CSSValueStart:
         return TextAlignLastStart;
     case CSSValueEnd:
         return TextAlignLastEnd;
     case CSSValueLeft:
         return TextAlignLastLeft;
     case CSSValueRight:
         return TextAlignLastRight;
@@ skipping 24 matching lines @@
         m_value.valueID = CSSValueInterWord;
         break;
     case TextJustifyDistribute:
         m_value.valueID = CSSValueDistribute;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator TextJustify() const
 {
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueAuto:
         return TextJustifyAuto;
     case CSSValueNone:
         return TextJustifyNone;
     case CSSValueInterWord:
         return TextJustifyInterWord;
     case CSSValueDistribute:
         return TextJustifyDistribute;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return TextJustifyAuto;
 }
 
 template<> inline CSSPrimitiveValue::operator TextDecoration() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueNone:
         return TextDecorationNone;
     case CSSValueUnderline:
         return TextDecorationUnderline;
     case CSSValueOverline:
         return TextDecorationOverline;
     case CSSValueLineThrough:
         return TextDecorationLineThrough;
     case CSSValueBlink:
         return TextDecorationBlink;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return TextDecorationNone;
 }
 
 template<> inline CSSPrimitiveValue::operator TextDecorationStyle() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueSolid:
         return TextDecorationStyleSolid;
     case CSSValueDouble:
         return TextDecorationStyleDouble;
     case CSSValueDotted:
         return TextDecorationStyleDotted;
     case CSSValueDashed:
         return TextDecorationStyleDashed;
     case CSSValueWavy:
         return TextDecorationStyleWavy;
@@ skipping 17 matching lines @@
         m_value.valueID = CSSValueUnder;
         break;
     }
 
     // FIXME: Implement support for 'under left' and 'under right' values.
 }
 
 template<> inline CSSPrimitiveValue::operator TextUnderlinePosition() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueAuto:
         return TextUnderlinePositionAuto;
     case CSSValueUnder:
         return TextUnderlinePositionUnder;
     default:
         break;
     }
 
     // FIXME: Implement support for 'under left' and 'under right' values.
 
@@ skipping 17 matching lines @@
         break;
     case TSSQUARE:
         m_value.valueID = CSSValueSquare;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator ETextSecurity() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueNone:
         return TSNONE;
     case CSSValueDisc:
         return TSDISC;
     case CSSValueCircle:
         return TSCIRCLE;
     case CSSValueSquare:
         return TSSQUARE;
     default:
         break;
@@ skipping 19 matching lines @@
         break;
     case TTNONE:
         m_value.valueID = CSSValueNone;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator ETextTransform() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueCapitalize:
         return CAPITALIZE;
     case CSSValueUppercase:
         return UPPERCASE;
     case CSSValueLowercase:
         return LOWERCASE;
     case CSSValueNone:
         return TTNONE;
     default:
         break;
@@ skipping 25 matching lines @@
         break;
     case Plaintext:
         m_value.valueID = CSSValueWebkitPlaintext;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EUnicodeBidi() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueNormal:
         return UBNormal;
     case CSSValueEmbed:
         return Embed;
     case CSSValueBidiOverride:
         return Override;
     case CSSValueWebkitIsolate:
         return Isolate;
     case CSSValueWebkitIsolateOverride:
         return IsolateOverride;
@@ skipping 22 matching lines @@
         m_value.valueID = CSSValueElement;
         break;
     default:
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EUserDrag() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueAuto:
         return DRAG_AUTO;
     case CSSValueNone:
         return DRAG_NONE;
     case CSSValueElement:
         return DRAG_ELEMENT;
     default:
         break;
     }
 
@@ skipping 14 matching lines @@
         break;
     case READ_WRITE_PLAINTEXT_ONLY:
         m_value.valueID = CSSValueReadWritePlaintextOnly;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EUserModify() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueReadOnly:
         return READ_ONLY;
     case CSSValueReadWrite:
         return READ_WRITE;
     case CSSValueReadWritePlaintextOnly:
         return READ_WRITE_PLAINTEXT_ONLY;
     default:
         break;
     }
 
@@ skipping 14 matching lines @@
         break;
     case SELECT_ALL:
         m_value.valueID = CSSValueAll;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EUserSelect() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueAuto:
         return SELECT_TEXT;
     case CSSValueNone:
         return SELECT_NONE;
     case CSSValueText:
         return SELECT_TEXT;
     case CSSValueAll:
         return SELECT_ALL;
     default:
         break;
@@ skipping 36 matching lines @@
         m_value.valueID = CSSValueWebkitBaselineMiddle;
         break;
     case LENGTH:
         m_value.valueID = CSSValueInvalid;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EVerticalAlign() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueTop:
         return TOP;
     case CSSValueBottom:
         return BOTTOM;
     case CSSValueMiddle:
         return MIDDLE;
     case CSSValueBaseline:
         return BASELINE;
     case CSSValueTextBottom:
         return TEXT_BOTTOM;
@@ skipping 26 matching lines @@
         break;
     case COLLAPSE:
         m_value.valueID = CSSValueCollapse;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EVisibility() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueHidden:
         return HIDDEN;
     case CSSValueVisible:
         return VISIBLE;
     case CSSValueCollapse:
         return COLLAPSE;
     default:
         break;
     }
 
@@ skipping 23 matching lines @@
         break;
     case KHTML_NOWRAP:
         m_value.valueID = CSSValueWebkitNowrap;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EWhiteSpace() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueWebkitNowrap:
         return KHTML_NOWRAP;
     case CSSValueNowrap:
         return NOWRAP;
     case CSSValuePre:
         return PRE;
     case CSSValuePreWrap:
         return PRE_WRAP;
     case CSSValuePreLine:
         return PRE_LINE;
@@ skipping 23 matching lines @@
         break;
     case KeepAllWordBreak:
         m_value.valueID = CSSValueKeepAll;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EWordBreak() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueBreakAll:
         return BreakAllWordBreak;
     case CSSValueBreakWord:
         return BreakWordBreak;
     case CSSValueNormal:
         return NormalWordBreak;
     case CSSValueKeepAll:
         return KeepAllWordBreak;
     default:
         break;
@@ skipping 13 matching lines @@
         break;
     case BreakOverflowWrap:
         m_value.valueID = CSSValueBreakWord;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EOverflowWrap() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueBreakWord:
         return BreakOverflowWrap;
     case CSSValueNormal:
         return NormalOverflowWrap;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return NormalOverflowWrap;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextDirection e)
     : CSSValue(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case LTR:
         m_value.valueID = CSSValueLtr;
         break;
     case RTL:
         m_value.valueID = CSSValueRtl;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator TextDirection() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueLtr:
         return LTR;
     case CSSValueRtl:
         return RTL;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return LTR;
@@ skipping 15 matching lines @@
         break;
     case BottomToTopWritingMode:
         m_value.valueID = CSSValueHorizontalBt;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator WritingMode() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueHorizontalTb:
         return TopToBottomWritingMode;
     case CSSValueVerticalRl:
         return RightToLeftWritingMode;
     case CSSValueVerticalLr:
         return LeftToRightWritingMode;
     case CSSValueHorizontalBt:
         return BottomToTopWritingMode;
     default:
         break;
@@ skipping 13 matching lines @@
         break;
     case TextCombineHorizontal:
         m_value.valueID = CSSValueHorizontal;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator TextCombine() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueNone:
         return TextCombineNone;
     case CSSValueHorizontal:
         return TextCombineHorizontal;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return TextCombineNone;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(RubyPosition position)
     : CSSValue(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (position) {
     case RubyPositionBefore:
         m_value.valueID = CSSValueBefore;
         break;
     case RubyPositionAfter:
         m_value.valueID = CSSValueAfter;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator RubyPosition() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueBefore:
         return RubyPositionBefore;
     case CSSValueAfter:
         return RubyPositionAfter;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return RubyPositionBefore;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextEmphasisPosition position)
     : CSSValue(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (position) {
     case TextEmphasisPositionOver:
         m_value.valueID = CSSValueOver;
         break;
     case TextEmphasisPositionUnder:
         m_value.valueID = CSSValueUnder;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator TextEmphasisPosition() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueOver:
         return TextEmphasisPositionOver;
     case CSSValueUnder:
         return TextEmphasisPositionUnder;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return TextEmphasisPositionOver;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextOverflow overflow)
     : CSSValue(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (overflow) {
     case TextOverflowClip:
         m_value.valueID = CSSValueClip;
         break;
     case TextOverflowEllipsis:
         m_value.valueID = CSSValueEllipsis;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator TextOverflow() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueClip:
         return TextOverflowClip;
     case CSSValueEllipsis:
         return TextOverflowEllipsis;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return TextOverflowClip;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextEmphasisFill fill)
     : CSSValue(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (fill) {
     case TextEmphasisFillFilled:
         m_value.valueID = CSSValueFilled;
         break;
     case TextEmphasisFillOpen:
         m_value.valueID = CSSValueOpen;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator TextEmphasisFill() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueFilled:
         return TextEmphasisFillFilled;
     case CSSValueOpen:
         return TextEmphasisFillOpen;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return TextEmphasisFillFilled;
@@ skipping 24 matching lines @@
     case TextEmphasisMarkCustom:
         ASSERT_NOT_REACHED();
         m_value.valueID = CSSValueNone;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator TextEmphasisMark() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueNone:
         return TextEmphasisMarkNone;
     case CSSValueDot:
         return TextEmphasisMarkDot;
     case CSSValueCircle:
         return TextEmphasisMarkCircle;
     case CSSValueDoubleCircle:
         return TextEmphasisMarkDoubleCircle;
     case CSSValueTriangle:
         return TextEmphasisMarkTriangle;
@@ skipping 23 matching lines @@
         break;
     case TextOrientationUpright:
         m_value.valueID = CSSValueUpright;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator TextOrientation() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueSideways:
         return TextOrientationSideways;
     case CSSValueSidewaysRight:
         return TextOrientationSidewaysRight;
     case CSSValueVerticalRight:
         return TextOrientationVerticalRight;
     case CSSValueUpright:
         return TextOrientationUpright;
     default:
         break;
@@ skipping 40 matching lines @@
         break;
     case PE_BOUNDINGBOX:
         m_value.valueID = CSSValueBoundingBox;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EPointerEvents() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueAll:
         return PE_ALL;
     case CSSValueAuto:
         return PE_AUTO;
     case CSSValueNone:
         return PE_NONE;
     case CSSValueVisiblePainted:
         return PE_VISIBLE_PAINTED;
     case CSSValueVisibleFill:
         return PE_VISIBLE_FILL;
@@ skipping 33 matching lines @@
         return;
     }
 
     ASSERT_NOT_REACHED();
     m_value.valueID = CSSValueAuto;
 }
 
 template<> inline CSSPrimitiveValue::operator FontDescription::Kerning() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueAuto:
         return FontDescription::AutoKerning;
     case CSSValueNormal:
         return FontDescription::NormalKerning;
     case CSSValueNone:
         return FontDescription::NoneKerning;
     default:
         break;
     }
 
@@ skipping 19 matching lines @@
         m_value.valueID = CSSValueNone;
         break;
     case ObjectFitScaleDown:
         m_value.valueID = CSSValueScaleDown;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator ObjectFit() const
 {
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueFill:
         return ObjectFitFill;
     case CSSValueContain:
         return ObjectFitContain;
     case CSSValueCover:
         return ObjectFitCover;
     case CSSValueNone:
         return ObjectFitNone;
     case CSSValueScaleDown:
         return ObjectFitScaleDown;
@@ skipping 42 matching lines @@
         return;
     }
 
     ASSERT_NOT_REACHED();
     m_value.valueID = CSSValueAuto;
 }
 
 template<> inline CSSPrimitiveValue::operator FontSmoothingMode() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueAuto:
         return AutoSmoothing;
     case CSSValueNone:
         return NoSmoothing;
     case CSSValueAntialiased:
         return Antialiased;
     case CSSValueSubpixelAntialiased:
         return SubpixelAntialiased;
     default:
         break;
@@ skipping 37 matching lines @@
         return;
     }
 
     ASSERT_NOT_REACHED();
     m_value.valueID = CSSValueNormal;
 }
 
 template<> inline CSSPrimitiveValue::operator FontWeight() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueBold:
         return FontWeightBold;
     case CSSValueNormal:
         return FontWeightNormal;
     case CSSValue900:
         return FontWeight900;
     case CSSValue800:
         return FontWeight800;
     case CSSValue700:
         return FontWeight700;
@@ skipping 30 matching lines @@
         return;
     }
 
     ASSERT_NOT_REACHED();
     m_value.valueID = CSSValueNormal;
 }
 
 template<> inline CSSPrimitiveValue::operator FontStyle() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueOblique:
     // FIXME: oblique is the same as italic for the moment...
     case CSSValueItalic:
         return FontStyleItalic;
     case CSSValueNormal:
         return FontStyleNormal;
     default:
         break;
     }
     ASSERT_NOT_REACHED();
@@ skipping 34 matching lines @@
         return;
     }
 
     ASSERT_NOT_REACHED();
     m_value.valueID = CSSValueNormal;
 }
 
 template<> inline CSSPrimitiveValue::operator FontStretch() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueUltraCondensed:
         return FontStretchUltraCondensed;
     case CSSValueExtraCondensed:
         return FontStretchExtraCondensed;
     case CSSValueCondensed:
         return FontStretchCondensed;
     case CSSValueSemiCondensed:
         return FontStretchSemiCondensed;
     case CSSValueNormal:
         return FontStretchNormal;
@@ skipping 26 matching lines @@
         return;
     }
 
     ASSERT_NOT_REACHED();
     m_value.valueID = CSSValueNormal;
 }
 
 template<> inline CSSPrimitiveValue::operator FontVariant() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueSmallCaps:
         return FontVariantSmallCaps;
     case CSSValueNormal:
         return FontVariantNormal;
     default:
         break;
     }
     ASSERT_NOT_REACHED();
     return FontVariantNormal;
 }
@@ skipping 14 matching lines @@
         break;
     case GeometricPrecision:
         m_value.valueID = CSSValueGeometricPrecision;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator TextRenderingMode() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueAuto:
         return AutoTextRendering;
     case CSSValueOptimizeSpeed:
         return OptimizeSpeed;
     case CSSValueOptimizeLegibility:
         return OptimizeLegibility;
     case CSSValueGeometricPrecision:
         return GeometricPrecision;
     default:
         break;
@@ skipping 25 matching lines @@
         break;
     case SpeakNoPunctuation:
         m_value.valueID = CSSValueNoPunctuation;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator Order() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueLogical:
         return LogicalOrder;
     case CSSValueVisual:
         return VisualOrder;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return LogicalOrder;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(Order e)
     : CSSValue(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case LogicalOrder:
         m_value.valueID = CSSValueLogical;
         break;
     case VisualOrder:
         m_value.valueID = CSSValueVisual;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator ESpeak() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueNone:
         return SpeakNone;
     case CSSValueNormal:
         return SpeakNormal;
     case CSSValueSpellOut:
         return SpeakSpellOut;
     case CSSValueDigits:
         return SpeakDigits;
     case CSSValueLiteralPunctuation:
         return SpeakLiteralPunctuation;
@@ skipping 59 matching lines @@
         break;
     case WebBlendModeLuminosity:
         m_value.valueID = CSSValueLuminosity;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator WebBlendMode() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueNormal:
         return WebBlendModeNormal;
     case CSSValueMultiply:
         return WebBlendModeMultiply;
     case CSSValueScreen:
         return WebBlendModeScreen;
     case CSSValueOverlay:
         return WebBlendModeOverlay;
     case CSSValueDarken:
         return WebBlendModeDarken;
@@ skipping 40 matching lines @@
         break;
     case SquareCap:
         m_value.valueID = CSSValueSquare;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator LineCap() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueButt:
         return ButtCap;
     case CSSValueRound:
         return RoundCap;
     case CSSValueSquare:
         return SquareCap;
     default:
         break;
     }
 
@@ skipping 14 matching lines @@
         break;
     case BevelJoin:
         m_value.valueID = CSSValueBevel;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator LineJoin() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueMiter:
         return MiterJoin;
     case CSSValueRound:
         return RoundJoin;
     case CSSValueBevel:
         return BevelJoin;
     default:
         break;
     }
 
@@ skipping 11 matching lines @@
         break;
     case RULE_EVENODD:
         m_value.valueID = CSSValueEvenodd;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator WindRule() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueNonzero:
         return RULE_NONZERO;
     case CSSValueEvenodd:
         return RULE_EVENODD;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return RULE_NONZERO;
@@ skipping 40 matching lines @@
         break;
     case AB_MATHEMATICAL:
         m_value.valueID = CSSValueMathematical;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EAlignmentBaseline() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueAuto:
         return AB_AUTO;
     case CSSValueBaseline:
         return AB_BASELINE;
     case CSSValueBeforeEdge:
         return AB_BEFORE_EDGE;
     case CSSValueTextBeforeEdge:
         return AB_TEXT_BEFORE_EDGE;
     case CSSValueMiddle:
         return AB_MIDDLE;
@@ skipping 29 matching lines @@
         break;
     case BCOLLAPSE:
         m_value.valueID = CSSValueCollapse;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EBorderCollapse() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueSeparate:
         return BSEPARATE;
     case CSSValueCollapse:
         return BCOLLAPSE;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return BSEPARATE;
@@ skipping 18 matching lines @@
         break;
     case ImageRenderingOptimizeContrast:
         m_value.valueID = CSSValueWebkitOptimizeContrast;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EImageRendering() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueAuto:
         return ImageRenderingAuto;
     case CSSValueOptimizeSpeed:
         return ImageRenderingOptimizeSpeed;
     case CSSValueOptimizeQuality:
         return ImageRenderingOptimizeQuality;
     case CSSValuePixelated:
         return ImageRenderingPixelated;
     case CSSValueWebkitOptimizeContrast:
         return ImageRenderingOptimizeContrast;
@@ skipping 15 matching lines @@
         break;
     case TransformStyle3DPreserve3D:
         m_value.valueID = CSSValuePreserve3d;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator ETransformStyle3D() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueFlat:
         return TransformStyle3DFlat;
     case CSSValuePreserve3d:
         return TransformStyle3DPreserve3D;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return TransformStyle3DFlat;
@@ skipping 12 matching lines @@
         break;
     case BR_STATIC:
         m_value.valueID = CSSValueStatic;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EBufferedRendering() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueAuto:
         return BR_AUTO;
     case CSSValueDynamic:
         return BR_DYNAMIC;
     case CSSValueStatic:
         return BR_STATIC;
     default:
         break;
     }
 
@@ skipping 14 matching lines @@
         break;
     case CI_LINEARRGB:
         m_value.valueID = CSSValueLinearRGB;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EColorInterpolation() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueSRGB:
         return CI_SRGB;
     case CSSValueLinearRGB:
         return CI_LINEARRGB;
     case CSSValueAuto:
         return CI_AUTO;
     default:
         break;
     }
 
@@ skipping 14 matching lines @@
         break;
     case CR_OPTIMIZEQUALITY:
         m_value.valueID = CSSValueOptimizeQuality;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EColorRendering() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueOptimizeSpeed:
         return CR_OPTIMIZESPEED;
     case CSSValueOptimizeQuality:
         return CR_OPTIMIZEQUALITY;
     case CSSValueAuto:
         return CR_AUTO;
     default:
         break;
     }
 
@@ skipping 41 matching lines @@
         break;
     case DB_MATHEMATICAL:
         m_value.valueID = CSSValueMathematical;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EDominantBaseline() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueAuto:
         return DB_AUTO;
     case CSSValueUseScript:
         return DB_USE_SCRIPT;
     case CSSValueNoChange:
         return DB_NO_CHANGE;
     case CSSValueResetSize:
         return DB_RESET_SIZE;
     case CSSValueIdeographic:
         return DB_IDEOGRAPHIC;
@@ skipping 35 matching lines @@
         break;
     case SR_GEOMETRICPRECISION:
         m_value.valueID = CSSValueGeometricPrecision;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EShapeRendering() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueAuto:
         return SR_AUTO;
     case CSSValueOptimizeSpeed:
         return SR_OPTIMIZESPEED;
     case CSSValueCrispEdges:
         return SR_CRISPEDGES;
     case CSSValueGeometricPrecision:
         return SR_GEOMETRICPRECISION;
     default:
         break;
@@ skipping 16 matching lines @@
         break;
     case TA_END:
         m_value.valueID = CSSValueEnd;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator ETextAnchor() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueStart:
         return TA_START;
     case CSSValueMiddle:
         return TA_MIDDLE;
     case CSSValueEnd:
         return TA_END;
     default:
         break;
     }
 
@@ skipping 23 matching lines @@
         break;
     case WM_TB:
         m_value.valueID = CSSValueTb;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator SVGWritingMode() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueLrTb:
         return WM_LRTB;
     case CSSValueLr:
         return WM_LR;
     case CSSValueRlTb:
         return WM_RLTB;
     case CSSValueRl:
         return WM_RL;
     case CSSValueTbRl:
         return WM_TBRL;
@@ skipping 17 matching lines @@
         break;
     case VE_NON_SCALING_STROKE:
         m_value.valueID = CSSValueNonScalingStroke;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EVectorEffect() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueNone:
         return VE_NONE;
     case CSSValueNonScalingStroke:
         return VE_NON_SCALING_STROKE;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return VE_NONE;
@@ skipping 16 matching lines @@
     default:
         ASSERT_NOT_REACHED();
         m_value.valueID = CSSValueFill;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EPaintOrderType() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueFill:
         return PT_FILL;
     case CSSValueStroke:
         return PT_STROKE;
     case CSSValueMarkers:
         return PT_MARKERS;
     default:
         break;
     }
 
@@ skipping 11 matching lines @@
         break;
     case MT_ALPHA:
         m_value.valueID = CSSValueAlpha;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EMaskType() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueLuminance:
         return MT_LUMINANCE;
     case CSSValueAlpha:
         return MT_ALPHA;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return MT_LUMINANCE;
 }
 
 template<> inline CSSPrimitiveValue::operator TouchAction() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueNone:
         return TouchActionNone;
     case CSSValueAuto:
         return TouchActionAuto;
     case CSSValuePanLeft:
         return TouchActionPanLeft;
     case CSSValuePanRight:
         return TouchActionPanRight;
     case CSSValuePanX:
         return TouchActionPanX;
@@ skipping 23 matching lines @@
         break;
     case IsolationIsolate:
         m_value.valueID = CSSValueIsolate;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EIsolation() const
 {
     ASSERT(isValueID());
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueAuto:
         return IsolationAuto;
     case CSSValueIsolate:
         return IsolationIsolate;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return IsolationAuto;
 }
 
 template<> inline CSSPrimitiveValue::operator WebScrollBlocksOn() const
 {
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueNone:
         return WebScrollBlocksOnNone;
     case CSSValueStartTouch:
         return WebScrollBlocksOnStartTouch;
     case CSSValueWheelEvent:
         return WebScrollBlocksOnWheelEvent;
     case CSSValueScrollEvent:
         return WebScrollBlocksOnScrollEvent;
     default:
         break;
@@ skipping 86 matching lines @@
         m_value.valueID = CSSValueLeft;
         break;
     case ItemPositionRight:
         m_value.valueID = CSSValueRight;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator ItemPosition() const
 {
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueAuto:
         return ItemPositionAuto;
     case CSSValueStretch:
         return ItemPositionStretch;
     case CSSValueBaseline:
         return ItemPositionBaseline;
     case CSSValueLastBaseline:
         return ItemPositionLastBaseline;
     case CSSValueCenter:
         return ItemPositionCenter;
@@ skipping 53 matching lines @@
         m_value.valueID = CSSValueLeft;
         break;
     case ContentPositionRight:
         m_value.valueID = CSSValueRight;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator ContentPosition() const
 {
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueAuto:
         return ContentPositionAuto;
     case CSSValueBaseline:
         return ContentPositionBaseline;
     case CSSValueLastBaseline:
         return ContentPositionLastBaseline;
     case CSSValueCenter:
         return ContentPositionCenter;
     case CSSValueStart:
         return ContentPositionStart;
@@ skipping 32 matching lines @@
         m_value.valueID = CSSValueSpaceEvenly;
         break;
     case ContentDistributionStretch:
         m_value.valueID = CSSValueStretch;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator ContentDistributionType() const
 {
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueSpaceBetween:
         return ContentDistributionSpaceBetween;
     case CSSValueSpaceAround:
         return ContentDistributionSpaceAround;
     case CSSValueSpaceEvenly:
         return ContentDistributionSpaceEvenly;
     case CSSValueStretch:
         return ContentDistributionStretch;
     default:
         break;
@@ skipping 14 matching lines @@
         m_value.valueID = CSSValueTrue;
         break;
     case OverflowAlignmentSafe:
         m_value.valueID = CSSValueSafe;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator OverflowAlignment() const
 {
-    switch (value().valueID) {
+    switch (valueIDValue()) {
     case CSSValueTrue:
         return OverflowAlignmentTrue;
     case CSSValueSafe:
         return OverflowAlignmentSafe;
     default:
         break;
     }
     ASSERT_NOT_REACHED();
     return OverflowAlignmentTrue;
 }
@@ skipping 59 matching lines @@
     default:
         break;
     }
     ASSERT_NOT_REACHED();
     return ScrollSnapTypeNone;
 }
 
 } // namespace blink
 
 #endif