CSSValue Immediates: Make CSSPrimitiveValue a container

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 38 matching lines @@
 #include "platform/text/TextDirection.h"
 #include "platform/text/TextRun.h"
 #include "platform/text/UnicodeBidi.h"
 #include "platform/text/WritingMode.h"
 #include "public/platform/WebBlendMode.h"
 #include "public/platform/WebScrollBlocksOn.h"
 #include "wtf/MathExtras.h"
 
 namespace blink {
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(short i)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(short i)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_NUMBER;
     m_value.num = static_cast<double>(i);
 }
 
 template<> inline CSSPrimitiveValue::operator short() const
 {
     ASSERT(isNumber());
     return clampTo<short>(getDoubleValue());
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(unsigned short i)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(unsigned short i)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_NUMBER;
     m_value.num = static_cast<double>(i);
 }
 
 template<> inline CSSPrimitiveValue::operator unsigned short() const
 {
     ASSERT(isNumber());
     return clampTo<unsigned short>(getDoubleValue());
 }
 
 template<> inline CSSPrimitiveValue::operator int() const
 {
     ASSERT(isNumber());
     return clampTo<int>(getDoubleValue());
 }
 
 template<> inline CSSPrimitiveValue::operator unsigned() const
 {
     ASSERT(isNumber());
     return clampTo<unsigned>(getDoubleValue());
 }
 
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(float i)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(float i)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_NUMBER;
     m_value.num = static_cast<double>(i);
 }
 
 template<> inline CSSPrimitiveValue::operator float() const
 {
     ASSERT(isNumber());
     return clampTo<float>(getDoubleValue());
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineClampValue i)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(LineClampValue i)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = i.isPercentage() ? CSS_PERCENTAGE : CSS_NUMBER;
     m_value.num = static_cast<double>(i.value());
 }
 
 template<> inline CSSPrimitiveValue::operator LineClampValue() const
 {
-    if (m_primitiveUnitType == CSS_NUMBER)
-        return LineClampValue(clampTo<int>(m_value.num), LineClampLineCount);
+    if (type() == CSS_NUMBER)
+        return LineClampValue(clampTo<int>(value().num), LineClampLineCount);
 
-    if (m_primitiveUnitType == CSS_PERCENTAGE)
-        return LineClampValue(clampTo<int>(m_value.num), LineClampPercentage);
+    if (type() == CSS_PERCENTAGE)
+        return LineClampValue(clampTo<int>(value().num), LineClampPercentage);
 
     ASSERT_NOT_REACHED();
     return LineClampValue();
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(CSSReflectionDirection e)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(CSSReflectionDirection e)
     : CSSValueObject(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 (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueAbove:
         return ReflectionAbove;
     case CSSValueBelow:
         return ReflectionBelow;
     case CSSValueLeft:
         return ReflectionLeft;
     case CSSValueRight:
         return ReflectionRight;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return ReflectionBelow;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ColumnFill columnFill)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(ColumnFill columnFill)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (columnFill) {
     case ColumnFillAuto:
         m_value.valueID = CSSValueAuto;
         break;
     case ColumnFillBalance:
         m_value.valueID = CSSValueBalance;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator ColumnFill() const
 {
-    if (m_primitiveUnitType == CSS_VALUE_ID) {
-        if (m_value.valueID == CSSValueBalance)
+    if (type() == CSS_VALUE_ID) {
+        if (value().valueID == CSSValueBalance)
             return ColumnFillBalance;
-        if (m_value.valueID == CSSValueAuto)
+        if (value().valueID == CSSValueAuto)
             return ColumnFillAuto;
     }
     ASSERT_NOT_REACHED();
     return ColumnFillBalance;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ColumnSpan columnSpan)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(ColumnSpan columnSpan)
     : CSSValueObject(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 (m_primitiveUnitType == CSS_NUMBER && m_value.num == 1)
+    if (type() == CSS_NUMBER && value().num == 1)
         return ColumnSpanNone;
 
     ASSERT(isValueID());
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueAll:
         return ColumnSpanAll;
     case CSSValueNone:
         return ColumnSpanNone;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return ColumnSpanNone;
 }
 
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(PrintColorAdjust value)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(PrintColorAdjust value)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (value) {
     case PrintColorAdjustExact:
         m_value.valueID = CSSValueExact;
         break;
     case PrintColorAdjustEconomy:
         m_value.valueID = CSSValueEconomy;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator PrintColorAdjust() const
 {
     ASSERT(isValueID());
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueEconomy:
         return PrintColorAdjustEconomy;
     case CSSValueExact:
         return PrintColorAdjustExact;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return PrintColorAdjustEconomy;
 }
 
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBorderStyle e)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(EBorderStyle e)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case BNONE:
         m_value.valueID = CSSValueNone;
         break;
     case BHIDDEN:
         m_value.valueID = CSSValueHidden;
         break;
@@ skipping 20 matching lines @@
         break;
     case DOUBLE:
         m_value.valueID = CSSValueDouble;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EBorderStyle() const
 {
     ASSERT(isValueID());
-    if (m_value.valueID == CSSValueAuto) // Valid for CSS outline-style
+    if (value().valueID == CSSValueAuto) // Valid for CSS outline-style
         return DOTTED;
-    return (EBorderStyle)(m_value.valueID - CSSValueNone);
+    return (EBorderStyle)(value().valueID - CSSValueNone);
 }
 
 template<> inline CSSPrimitiveValue::operator OutlineIsAuto() const
 {
-    if (m_value.valueID == CSSValueAuto)
+    if (value().valueID == CSSValueAuto)
         return AUTO_ON;
     return AUTO_OFF;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(CompositeOperator e)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(CompositeOperator e)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case CompositeClear:
         m_value.valueID = CSSValueClear;
         break;
     case CompositeCopy:
         m_value.valueID = CSSValueCopy;
         break;
@@ skipping 29 matching lines @@
         break;
     default:
         ASSERT_NOT_REACHED();
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator CompositeOperator() const
 {
     ASSERT(isValueID());
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueClear:
         return CompositeClear;
     case CSSValueCopy:
         return CompositeCopy;
     case CSSValueSourceOver:
         return CompositeSourceOver;
     case CSSValueSourceIn:
         return CompositeSourceIn;
     case CSSValueSourceOut:
         return CompositeSourceOut;
@@ skipping 12 matching lines @@
     case CSSValuePlusLighter:
         return CompositePlusLighter;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return CompositeClear;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ControlPart e)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(ControlPart e)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case NoControlPart:
         m_value.valueID = CSSValueNone;
         break;
     case CheckboxPart:
         m_value.valueID = CSSValueCheckbox;
         break;
@@ skipping 146 matching lines @@
         break;
     case CapsLockIndicatorPart:
         m_value.valueID = CSSValueCapsLockIndicator;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator ControlPart() const
 {
     ASSERT(isValueID());
-    if (m_value.valueID == CSSValueNone)
+    if (value().valueID == CSSValueNone)
         return NoControlPart;
-    return ControlPart(m_value.valueID - CSSValueCheckbox + 1);
+    return ControlPart(value().valueID - CSSValueCheckbox + 1);
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBackfaceVisibility e)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(EBackfaceVisibility e)
     : CSSValueObject(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 (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueVisible:
         return BackfaceVisibilityVisible;
     case CSSValueHidden:
         return BackfaceVisibilityHidden;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return BackfaceVisibilityHidden;
 }
 
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFillAttachment e)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(EFillAttachment e)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case ScrollBackgroundAttachment:
         m_value.valueID = CSSValueScroll;
         break;
     case LocalBackgroundAttachment:
         m_value.valueID = CSSValueLocal;
         break;
     case FixedBackgroundAttachment:
         m_value.valueID = CSSValueFixed;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EFillAttachment() const
 {
     ASSERT(isValueID());
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueScroll:
         return ScrollBackgroundAttachment;
     case CSSValueLocal:
         return LocalBackgroundAttachment;
     case CSSValueFixed:
         return FixedBackgroundAttachment;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return ScrollBackgroundAttachment;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFillBox e)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(EFillBox e)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case BorderFillBox:
         m_value.valueID = CSSValueBorderBox;
         break;
     case PaddingFillBox:
         m_value.valueID = CSSValuePaddingBox;
         break;
     case ContentFillBox:
         m_value.valueID = CSSValueContentBox;
         break;
     case TextFillBox:
         m_value.valueID = CSSValueText;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EFillBox() const
 {
     ASSERT(isValueID());
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueBorder:
     case CSSValueBorderBox:
         return BorderFillBox;
     case CSSValuePadding:
     case CSSValuePaddingBox:
         return PaddingFillBox;
     case CSSValueContent:
     case CSSValueContentBox:
         return ContentFillBox;
     case CSSValueText:
     case CSSValueWebkitText:
         return TextFillBox;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return BorderFillBox;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFillRepeat e)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(EFillRepeat e)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case RepeatFill:
         m_value.valueID = CSSValueRepeat;
         break;
     case NoRepeatFill:
         m_value.valueID = CSSValueNoRepeat;
         break;
     case RoundFill:
         m_value.valueID = CSSValueRound;
         break;
     case SpaceFill:
         m_value.valueID = CSSValueSpace;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EFillRepeat() const
 {
     ASSERT(isValueID());
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueRepeat:
         return RepeatFill;
     case CSSValueNoRepeat:
         return NoRepeatFill;
     case CSSValueRound:
         return RoundFill;
     case CSSValueSpace:
         return SpaceFill;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return RepeatFill;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxPack e)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(EBoxPack e)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case Start:
         m_value.valueID = CSSValueStart;
         break;
     case Center:
         m_value.valueID = CSSValueCenter;
         break;
     case End:
         m_value.valueID = CSSValueEnd;
         break;
     case Justify:
         m_value.valueID = CSSValueJustify;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EBoxPack() const
 {
     ASSERT(isValueID());
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueStart:
         return Start;
     case CSSValueEnd:
         return End;
     case CSSValueCenter:
         return Center;
     case CSSValueJustify:
         return Justify;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return Justify;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxAlignment e)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(EBoxAlignment e)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case BSTRETCH:
         m_value.valueID = CSSValueStretch;
         break;
     case BSTART:
         m_value.valueID = CSSValueStart;
         break;
     case BCENTER:
         m_value.valueID = CSSValueCenter;
         break;
     case BEND:
         m_value.valueID = CSSValueEnd;
         break;
     case BBASELINE:
         m_value.valueID = CSSValueBaseline;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EBoxAlignment() const
 {
     ASSERT(isValueID());
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueStretch:
         return BSTRETCH;
     case CSSValueStart:
         return BSTART;
     case CSSValueEnd:
         return BEND;
     case CSSValueCenter:
         return BCENTER;
     case CSSValueBaseline:
         return BBASELINE;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return BSTRETCH;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxDecorationBreak e)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(EBoxDecorationBreak e)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case DSLICE:
         m_value.valueID = CSSValueSlice;
         break;
     case DCLONE:
         m_value.valueID = CSSValueClone;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EBoxDecorationBreak() const
 {
     ASSERT(isValueID());
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueSlice:
         return DSLICE;
     case CSSValueClone:
         return DCLONE;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return DSLICE;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(BackgroundEdgeOrigin e)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(BackgroundEdgeOrigin e)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case TopEdge:
         m_value.valueID = CSSValueTop;
         break;
     case RightEdge:
         m_value.valueID = CSSValueRight;
         break;
     case BottomEdge:
         m_value.valueID = CSSValueBottom;
         break;
     case LeftEdge:
         m_value.valueID = CSSValueLeft;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator BackgroundEdgeOrigin() const
 {
     ASSERT(isValueID());
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueTop:
         return TopEdge;
     case CSSValueRight:
         return RightEdge;
     case CSSValueBottom:
         return BottomEdge;
     case CSSValueLeft:
         return LeftEdge;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return TopEdge;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxSizing e)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(EBoxSizing e)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case BORDER_BOX:
         m_value.valueID = CSSValueBorderBox;
         break;
     case CONTENT_BOX:
         m_value.valueID = CSSValueContentBox;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EBoxSizing() const
 {
     ASSERT(isValueID());
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueBorderBox:
         return BORDER_BOX;
     case CSSValueContentBox:
         return CONTENT_BOX;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return BORDER_BOX;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxDirection e)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(EBoxDirection e)
     : CSSValueObject(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 (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueNormal:
         return BNORMAL;
     case CSSValueReverse:
         return BREVERSE;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return BNORMAL;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxLines e)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(EBoxLines e)
     : CSSValueObject(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 (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueSingle:
         return SINGLE;
     case CSSValueMultiple:
         return MULTIPLE;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return SINGLE;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxOrient e)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(EBoxOrient e)
     : CSSValueObject(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 (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueHorizontal:
     case CSSValueInlineAxis:
         return HORIZONTAL;
     case CSSValueVertical:
     case CSSValueBlockAxis:
         return VERTICAL;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return HORIZONTAL;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ECaptionSide e)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(ECaptionSide e)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case CAPLEFT:
         m_value.valueID = CSSValueLeft;
         break;
     case CAPRIGHT:
         m_value.valueID = CSSValueRight;
         break;
     case CAPTOP:
         m_value.valueID = CSSValueTop;
         break;
     case CAPBOTTOM:
         m_value.valueID = CSSValueBottom;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator ECaptionSide() const
 {
     ASSERT(isValueID());
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueLeft:
         return CAPLEFT;
     case CSSValueRight:
         return CAPRIGHT;
     case CSSValueTop:
         return CAPTOP;
     case CSSValueBottom:
         return CAPBOTTOM;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return CAPTOP;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EClear e)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(EClear e)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case CNONE:
         m_value.valueID = CSSValueNone;
         break;
     case CLEFT:
         m_value.valueID = CSSValueLeft;
         break;
     case CRIGHT:
         m_value.valueID = CSSValueRight;
         break;
     case CBOTH:
         m_value.valueID = CSSValueBoth;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EClear() const
 {
     ASSERT(isValueID());
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueNone:
         return CNONE;
     case CSSValueLeft:
         return CLEFT;
     case CSSValueRight:
         return CRIGHT;
     case CSSValueBoth:
         return CBOTH;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return CNONE;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ECursor e)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(ECursor e)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case CURSOR_AUTO:
         m_value.valueID = CSSValueAuto;
         break;
     case CURSOR_CROSS:
         m_value.valueID = CSSValueCrosshair;
         break;
@@ skipping 98 matching lines @@
         break;
     case CURSOR_WEBKIT_GRABBING:
         m_value.valueID = CSSValueWebkitGrabbing;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator ECursor() const
 {
     ASSERT(isValueID());
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     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>(m_value.valueID - CSSValueAuto);
+        return static_cast<ECursor>(value().valueID - CSSValueAuto);
     }
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EDisplay e)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(EDisplay e)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case INLINE:
         m_value.valueID = CSSValueInline;
         break;
     case BLOCK:
         m_value.valueID = CSSValueBlock;
         break;
@@ skipping 53 matching lines @@
         break;
     case NONE:
         m_value.valueID = CSSValueNone;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EDisplay() const
 {
     ASSERT(isValueID());
-    if (m_value.valueID == CSSValueNone)
+    if (value().valueID == CSSValueNone)
         return NONE;
 
-    if (m_value.valueID == CSSValueWebkitFlex)
+    if (value().valueID == CSSValueWebkitFlex)
         return FLEX;
-    if (m_value.valueID == CSSValueWebkitInlineFlex)
+    if (value().valueID == CSSValueWebkitInlineFlex)
         return INLINE_FLEX;
 
-    EDisplay display = static_cast<EDisplay>(m_value.valueID - CSSValueInline);
+    EDisplay display = static_cast<EDisplay>(value().valueID - CSSValueInline);
     ASSERT(display >= INLINE && display <= NONE);
     return display;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EEmptyCell e)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(EEmptyCell e)
     : CSSValueObject(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 (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueShow:
         return SHOW;
     case CSSValueHide:
         return HIDE;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return SHOW;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFlexDirection e)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(EFlexDirection e)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case FlowRow:
         m_value.valueID = CSSValueRow;
         break;
     case FlowRowReverse:
         m_value.valueID = CSSValueRowReverse;
         break;
     case FlowColumn:
         m_value.valueID = CSSValueColumn;
         break;
     case FlowColumnReverse:
         m_value.valueID = CSSValueColumnReverse;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EFlexDirection() const
 {
     ASSERT(isValueID());
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueRow:
         return FlowRow;
     case CSSValueRowReverse:
         return FlowRowReverse;
     case CSSValueColumn:
         return FlowColumn;
     case CSSValueColumnReverse:
         return FlowColumnReverse;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return FlowRow;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFlexWrap e)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(EFlexWrap e)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case FlexNoWrap:
         m_value.valueID = CSSValueNowrap;
         break;
     case FlexWrap:
         m_value.valueID = CSSValueWrap;
         break;
     case FlexWrapReverse:
         m_value.valueID = CSSValueWrapReverse;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EFlexWrap() const
 {
     ASSERT(isValueID());
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueNowrap:
         return FlexNoWrap;
     case CSSValueWrap:
         return FlexWrap;
     case CSSValueWrapReverse:
         return FlexWrapReverse;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return FlexNoWrap;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFloat e)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(EFloat e)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case NoFloat:
         m_value.valueID = CSSValueNone;
         break;
     case LeftFloat:
         m_value.valueID = CSSValueLeft;
         break;
     case RightFloat:
         m_value.valueID = CSSValueRight;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EFloat() const
 {
     ASSERT(isValueID());
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueLeft:
         return LeftFloat;
     case CSSValueRight:
         return RightFloat;
     case CSSValueNone:
         return NoFloat;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return NoFloat;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineBreak e)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(LineBreak e)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case LineBreakAuto:
         m_value.valueID = CSSValueAuto;
         break;
     case LineBreakLoose:
         m_value.valueID = CSSValueLoose;
         break;
     case LineBreakNormal:
         m_value.valueID = CSSValueNormal;
         break;
     case LineBreakStrict:
         m_value.valueID = CSSValueStrict;
         break;
     case LineBreakAfterWhiteSpace:
         m_value.valueID = CSSValueAfterWhiteSpace;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator LineBreak() const
 {
     ASSERT(isValueID());
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueAuto:
         return LineBreakAuto;
     case CSSValueLoose:
         return LineBreakLoose;
     case CSSValueNormal:
         return LineBreakNormal;
     case CSSValueStrict:
         return LineBreakStrict;
     case CSSValueAfterWhiteSpace:
         return LineBreakAfterWhiteSpace;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return LineBreakAuto;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EListStylePosition e)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(EListStylePosition e)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case OUTSIDE:
         m_value.valueID = CSSValueOutside;
         break;
     case INSIDE:
         m_value.valueID = CSSValueInside;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EListStylePosition() const
 {
     ASSERT(isValueID());
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueOutside:
         return OUTSIDE;
     case CSSValueInside:
         return INSIDE;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return OUTSIDE;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EListStyleType e)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(EListStyleType e)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case ArabicIndic:
         m_value.valueID = CSSValueArabicIndic;
         break;
     case Armenian:
         m_value.valueID = CSSValueArmenian;
         break;
@@ skipping 158 matching lines @@
         break;
     case Urdu:
         m_value.valueID = CSSValueUrdu;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EListStyleType() const
 {
     ASSERT(isValueID());
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueNone:
         return NoneListStyle;
     default:
-        return static_cast<EListStyleType>(m_value.valueID - CSSValueDisc);
+        return static_cast<EListStyleType>(value().valueID - CSSValueDisc);
     }
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EMarginCollapse e)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(EMarginCollapse e)
     : CSSValueObject(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 (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueCollapse:
         return MCOLLAPSE;
     case CSSValueSeparate:
         return MSEPARATE;
     case CSSValueDiscard:
         return MDISCARD;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return MCOLLAPSE;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EOverflow e)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(EOverflow e)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case OVISIBLE:
         m_value.valueID = CSSValueVisible;
         break;
     case OHIDDEN:
         m_value.valueID = CSSValueHidden;
         break;
@@ skipping 11 matching lines @@
         break;
     case OPAGEDY:
         m_value.valueID = CSSValueWebkitPagedY;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EOverflow() const
 {
     ASSERT(isValueID());
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueVisible:
         return OVISIBLE;
     case CSSValueHidden:
         return OHIDDEN;
     case CSSValueScroll:
         return OSCROLL;
     case CSSValueAuto:
         return OAUTO;
     case CSSValueOverlay:
         return OOVERLAY;
     case CSSValueWebkitPagedX:
         return OPAGEDX;
     case CSSValueWebkitPagedY:
         return OPAGEDY;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return OVISIBLE;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EPageBreak e)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(EPageBreak e)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case PBAUTO:
         m_value.valueID = CSSValueAuto;
         break;
     case PBALWAYS:
         m_value.valueID = CSSValueAlways;
         break;
     case PBAVOID:
         m_value.valueID = CSSValueAvoid;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EPageBreak() const
 {
     ASSERT(isValueID());
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     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;
     }
 
     ASSERT_NOT_REACHED();
     return PBAUTO;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EPosition e)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(EPosition e)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case StaticPosition:
         m_value.valueID = CSSValueStatic;
         break;
     case RelativePosition:
         m_value.valueID = CSSValueRelative;
         break;
     case AbsolutePosition:
         m_value.valueID = CSSValueAbsolute;
         break;
     case FixedPosition:
         m_value.valueID = CSSValueFixed;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EPosition() const
 {
     ASSERT(isValueID());
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueStatic:
         return StaticPosition;
     case CSSValueRelative:
         return RelativePosition;
     case CSSValueAbsolute:
         return AbsolutePosition;
     case CSSValueFixed:
         return FixedPosition;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return StaticPosition;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EResize e)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(EResize e)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case RESIZE_BOTH:
         m_value.valueID = CSSValueBoth;
         break;
     case RESIZE_HORIZONTAL:
         m_value.valueID = CSSValueHorizontal;
         break;
     case RESIZE_VERTICAL:
         m_value.valueID = CSSValueVertical;
         break;
     case RESIZE_NONE:
         m_value.valueID = CSSValueNone;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EResize() const
 {
     ASSERT(isValueID());
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     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:
         return RESIZE_NONE;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return RESIZE_NONE;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETableLayout e)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(ETableLayout e)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case TAUTO:
         m_value.valueID = CSSValueAuto;
         break;
     case TFIXED:
         m_value.valueID = CSSValueFixed;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator ETableLayout() const
 {
     ASSERT(isValueID());
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueFixed:
         return TFIXED;
     case CSSValueAuto:
         return TAUTO;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return TAUTO;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETextAlign e)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(ETextAlign e)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case TASTART:
         m_value.valueID = CSSValueStart;
         break;
     case TAEND:
         m_value.valueID = CSSValueEnd;
         break;
@@ skipping 17 matching lines @@
         break;
     case WEBKIT_CENTER:
         m_value.valueID = CSSValueWebkitCenter;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator ETextAlign() const
 {
     ASSERT(isValueID());
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueWebkitAuto: // Legacy -webkit-auto. Eqiuvalent to start.
     case CSSValueStart:
         return TASTART;
     case CSSValueEnd:
         return TAEND;
     default:
-        return static_cast<ETextAlign>(m_value.valueID - CSSValueLeft);
+        return static_cast<ETextAlign>(value().valueID - CSSValueLeft);
     }
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextAlignLast e)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(TextAlignLast e)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case TextAlignLastStart:
         m_value.valueID = CSSValueStart;
         break;
     case TextAlignLastEnd:
         m_value.valueID = CSSValueEnd;
         break;
@@ skipping 11 matching lines @@
         break;
     case TextAlignLastAuto:
         m_value.valueID = CSSValueAuto;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator TextAlignLast() const
 {
     ASSERT(isValueID());
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueAuto:
         return TextAlignLastAuto;
     case CSSValueStart:
         return TextAlignLastStart;
     case CSSValueEnd:
         return TextAlignLastEnd;
     case CSSValueLeft:
         return TextAlignLastLeft;
     case CSSValueRight:
         return TextAlignLastRight;
     case CSSValueCenter:
         return TextAlignLastCenter;
     case CSSValueJustify:
         return TextAlignLastJustify;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return TextAlignLastAuto;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextJustify e)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(TextJustify e)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case TextJustifyAuto:
         m_value.valueID = CSSValueAuto;
         break;
     case TextJustifyNone:
         m_value.valueID = CSSValueNone;
         break;
     case TextJustifyInterWord:
         m_value.valueID = CSSValueInterWord;
         break;
     case TextJustifyDistribute:
         m_value.valueID = CSSValueDistribute;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator TextJustify() const
 {
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     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 (m_value.valueID) {
+    switch (value().valueID) {
     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 (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueSolid:
         return TextDecorationStyleSolid;
     case CSSValueDouble:
         return TextDecorationStyleDouble;
     case CSSValueDotted:
         return TextDecorationStyleDotted;
     case CSSValueDashed:
         return TextDecorationStyleDashed;
     case CSSValueWavy:
         return TextDecorationStyleWavy;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return TextDecorationStyleSolid;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextUnderlinePosition e)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(TextUnderlinePosition e)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case TextUnderlinePositionAuto:
         m_value.valueID = CSSValueAuto;
         break;
     case TextUnderlinePositionUnder:
         m_value.valueID = CSSValueUnder;
         break;
     }
 
     // FIXME: Implement support for 'under left' and 'under right' values.
 }
 
 template<> inline CSSPrimitiveValue::operator TextUnderlinePosition() const
 {
     ASSERT(isValueID());
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueAuto:
         return TextUnderlinePositionAuto;
     case CSSValueUnder:
         return TextUnderlinePositionUnder;
     default:
         break;
     }
 
     // FIXME: Implement support for 'under left' and 'under right' values.
 
     ASSERT_NOT_REACHED();
     return TextUnderlinePositionAuto;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETextSecurity e)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(ETextSecurity e)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case TSNONE:
         m_value.valueID = CSSValueNone;
         break;
     case TSDISC:
         m_value.valueID = CSSValueDisc;
         break;
     case TSCIRCLE:
         m_value.valueID = CSSValueCircle;
         break;
     case TSSQUARE:
         m_value.valueID = CSSValueSquare;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator ETextSecurity() const
 {
     ASSERT(isValueID());
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueNone:
         return TSNONE;
     case CSSValueDisc:
         return TSDISC;
     case CSSValueCircle:
         return TSCIRCLE;
     case CSSValueSquare:
         return TSSQUARE;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return TSNONE;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETextTransform e)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(ETextTransform e)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case CAPITALIZE:
         m_value.valueID = CSSValueCapitalize;
         break;
     case UPPERCASE:
         m_value.valueID = CSSValueUppercase;
         break;
     case LOWERCASE:
         m_value.valueID = CSSValueLowercase;
         break;
     case TTNONE:
         m_value.valueID = CSSValueNone;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator ETextTransform() const
 {
     ASSERT(isValueID());
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueCapitalize:
         return CAPITALIZE;
     case CSSValueUppercase:
         return UPPERCASE;
     case CSSValueLowercase:
         return LOWERCASE;
     case CSSValueNone:
         return TTNONE;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return TTNONE;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUnicodeBidi e)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(EUnicodeBidi e)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case UBNormal:
         m_value.valueID = CSSValueNormal;
         break;
     case Embed:
         m_value.valueID = CSSValueEmbed;
         break;
     case Override:
         m_value.valueID = CSSValueBidiOverride;
         break;
     case Isolate:
         m_value.valueID = CSSValueWebkitIsolate;
         break;
     case IsolateOverride:
         m_value.valueID = CSSValueWebkitIsolateOverride;
         break;
     case Plaintext:
         m_value.valueID = CSSValueWebkitPlaintext;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EUnicodeBidi() const
 {
     ASSERT(isValueID());
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueNormal:
         return UBNormal;
     case CSSValueEmbed:
         return Embed;
     case CSSValueBidiOverride:
         return Override;
     case CSSValueWebkitIsolate:
         return Isolate;
     case CSSValueWebkitIsolateOverride:
         return IsolateOverride;
     case CSSValueWebkitPlaintext:
         return Plaintext;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return UBNormal;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUserDrag e)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(EUserDrag e)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case DRAG_AUTO:
         m_value.valueID = CSSValueAuto;
         break;
     case DRAG_NONE:
         m_value.valueID = CSSValueNone;
         break;
     case DRAG_ELEMENT:
         m_value.valueID = CSSValueElement;
         break;
     default:
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EUserDrag() const
 {
     ASSERT(isValueID());
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueAuto:
         return DRAG_AUTO;
     case CSSValueNone:
         return DRAG_NONE;
     case CSSValueElement:
         return DRAG_ELEMENT;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return DRAG_AUTO;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUserModify e)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(EUserModify e)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case READ_ONLY:
         m_value.valueID = CSSValueReadOnly;
         break;
     case READ_WRITE:
         m_value.valueID = CSSValueReadWrite;
         break;
     case READ_WRITE_PLAINTEXT_ONLY:
         m_value.valueID = CSSValueReadWritePlaintextOnly;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EUserModify() const
 {
     ASSERT(isValueID());
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueReadOnly:
         return READ_ONLY;
     case CSSValueReadWrite:
         return READ_WRITE;
     case CSSValueReadWritePlaintextOnly:
         return READ_WRITE_PLAINTEXT_ONLY;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return READ_ONLY;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUserSelect e)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(EUserSelect e)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case SELECT_NONE:
         m_value.valueID = CSSValueNone;
         break;
     case SELECT_TEXT:
         m_value.valueID = CSSValueText;
         break;
     case SELECT_ALL:
         m_value.valueID = CSSValueAll;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EUserSelect() const
 {
     ASSERT(isValueID());
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueAuto:
         return SELECT_TEXT;
     case CSSValueNone:
         return SELECT_NONE;
     case CSSValueText:
         return SELECT_TEXT;
     case CSSValueAll:
         return SELECT_ALL;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return SELECT_TEXT;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EVerticalAlign a)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(EVerticalAlign a)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (a) {
     case TOP:
         m_value.valueID = CSSValueTop;
         break;
     case BOTTOM:
         m_value.valueID = CSSValueBottom;
         break;
@@ skipping 19 matching lines @@
         m_value.valueID = CSSValueWebkitBaselineMiddle;
         break;
     case LENGTH:
         m_value.valueID = CSSValueInvalid;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EVerticalAlign() const
 {
     ASSERT(isValueID());
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueTop:
         return TOP;
     case CSSValueBottom:
         return BOTTOM;
     case CSSValueMiddle:
         return MIDDLE;
     case CSSValueBaseline:
         return BASELINE;
     case CSSValueTextBottom:
         return TEXT_BOTTOM;
     case CSSValueTextTop:
         return TEXT_TOP;
     case CSSValueSub:
         return SUB;
     case CSSValueSuper:
         return SUPER;
     case CSSValueWebkitBaselineMiddle:
         return BASELINE_MIDDLE;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return TOP;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EVisibility e)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(EVisibility e)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case VISIBLE:
         m_value.valueID = CSSValueVisible;
         break;
     case HIDDEN:
         m_value.valueID = CSSValueHidden;
         break;
     case COLLAPSE:
         m_value.valueID = CSSValueCollapse;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EVisibility() const
 {
     ASSERT(isValueID());
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueHidden:
         return HIDDEN;
     case CSSValueVisible:
         return VISIBLE;
     case CSSValueCollapse:
         return COLLAPSE;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return VISIBLE;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EWhiteSpace e)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(EWhiteSpace e)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case NORMAL:
         m_value.valueID = CSSValueNormal;
         break;
     case PRE:
         m_value.valueID = CSSValuePre;
         break;
     case PRE_WRAP:
         m_value.valueID = CSSValuePreWrap;
         break;
     case PRE_LINE:
         m_value.valueID = CSSValuePreLine;
         break;
     case NOWRAP:
         m_value.valueID = CSSValueNowrap;
         break;
     case KHTML_NOWRAP:
         m_value.valueID = CSSValueWebkitNowrap;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EWhiteSpace() const
 {
     ASSERT(isValueID());
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueWebkitNowrap:
         return KHTML_NOWRAP;
     case CSSValueNowrap:
         return NOWRAP;
     case CSSValuePre:
         return PRE;
     case CSSValuePreWrap:
         return PRE_WRAP;
     case CSSValuePreLine:
         return PRE_LINE;
     case CSSValueNormal:
         return NORMAL;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return NORMAL;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EWordBreak e)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(EWordBreak e)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case NormalWordBreak:
         m_value.valueID = CSSValueNormal;
         break;
     case BreakAllWordBreak:
         m_value.valueID = CSSValueBreakAll;
         break;
     case BreakWordBreak:
         m_value.valueID = CSSValueBreakWord;
         break;
     case KeepAllWordBreak:
         m_value.valueID = CSSValueKeepAll;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EWordBreak() const
 {
     ASSERT(isValueID());
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueBreakAll:
         return BreakAllWordBreak;
     case CSSValueBreakWord:
         return BreakWordBreak;
     case CSSValueNormal:
         return NormalWordBreak;
     case CSSValueKeepAll:
         return KeepAllWordBreak;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return NormalWordBreak;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EOverflowWrap e)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(EOverflowWrap e)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case NormalOverflowWrap:
         m_value.valueID = CSSValueNormal;
         break;
     case BreakOverflowWrap:
         m_value.valueID = CSSValueBreakWord;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EOverflowWrap() const
 {
     ASSERT(isValueID());
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueBreakWord:
         return BreakOverflowWrap;
     case CSSValueNormal:
         return NormalOverflowWrap;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return NormalOverflowWrap;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextDirection e)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(TextDirection e)
     : CSSValueObject(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 (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueLtr:
         return LTR;
     case CSSValueRtl:
         return RTL;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return LTR;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(WritingMode e)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(WritingMode e)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case TopToBottomWritingMode:
         m_value.valueID = CSSValueHorizontalTb;
         break;
     case RightToLeftWritingMode:
         m_value.valueID = CSSValueVerticalRl;
         break;
     case LeftToRightWritingMode:
         m_value.valueID = CSSValueVerticalLr;
         break;
     case BottomToTopWritingMode:
         m_value.valueID = CSSValueHorizontalBt;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator WritingMode() const
 {
     ASSERT(isValueID());
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueHorizontalTb:
         return TopToBottomWritingMode;
     case CSSValueVerticalRl:
         return RightToLeftWritingMode;
     case CSSValueVerticalLr:
         return LeftToRightWritingMode;
     case CSSValueHorizontalBt:
         return BottomToTopWritingMode;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return TopToBottomWritingMode;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextCombine e)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(TextCombine e)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case TextCombineNone:
         m_value.valueID = CSSValueNone;
         break;
     case TextCombineHorizontal:
         m_value.valueID = CSSValueHorizontal;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator TextCombine() const
 {
     ASSERT(isValueID());
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueNone:
         return TextCombineNone;
     case CSSValueHorizontal:
         return TextCombineHorizontal;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return TextCombineNone;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(RubyPosition position)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(RubyPosition position)
     : CSSValueObject(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 (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueBefore:
         return RubyPositionBefore;
     case CSSValueAfter:
         return RubyPositionAfter;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return RubyPositionBefore;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextEmphasisPosition position)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(TextEmphasisPosition position)
     : CSSValueObject(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 (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueOver:
         return TextEmphasisPositionOver;
     case CSSValueUnder:
         return TextEmphasisPositionUnder;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return TextEmphasisPositionOver;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextOverflow overflow)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(TextOverflow overflow)
     : CSSValueObject(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 (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueClip:
         return TextOverflowClip;
     case CSSValueEllipsis:
         return TextOverflowEllipsis;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return TextOverflowClip;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextEmphasisFill fill)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(TextEmphasisFill fill)
     : CSSValueObject(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 (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueFilled:
         return TextEmphasisFillFilled;
     case CSSValueOpen:
         return TextEmphasisFillOpen;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return TextEmphasisFillFilled;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextEmphasisMark mark)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(TextEmphasisMark mark)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (mark) {
     case TextEmphasisMarkDot:
         m_value.valueID = CSSValueDot;
         break;
     case TextEmphasisMarkCircle:
         m_value.valueID = CSSValueCircle;
         break;
@@ skipping 11 matching lines @@
     case TextEmphasisMarkCustom:
         ASSERT_NOT_REACHED();
         m_value.valueID = CSSValueNone;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator TextEmphasisMark() const
 {
     ASSERT(isValueID());
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueNone:
         return TextEmphasisMarkNone;
     case CSSValueDot:
         return TextEmphasisMarkDot;
     case CSSValueCircle:
         return TextEmphasisMarkCircle;
     case CSSValueDoubleCircle:
         return TextEmphasisMarkDoubleCircle;
     case CSSValueTriangle:
         return TextEmphasisMarkTriangle;
     case CSSValueSesame:
         return TextEmphasisMarkSesame;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return TextEmphasisMarkNone;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextOrientation e)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(TextOrientation e)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case TextOrientationSideways:
         m_value.valueID = CSSValueSideways;
         break;
     case TextOrientationSidewaysRight:
         m_value.valueID = CSSValueSidewaysRight;
         break;
     case TextOrientationVerticalRight:
         m_value.valueID = CSSValueVerticalRight;
         break;
     case TextOrientationUpright:
         m_value.valueID = CSSValueUpright;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator TextOrientation() const
 {
     ASSERT(isValueID());
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueSideways:
         return TextOrientationSideways;
     case CSSValueSidewaysRight:
         return TextOrientationSidewaysRight;
     case CSSValueVerticalRight:
         return TextOrientationVerticalRight;
     case CSSValueUpright:
         return TextOrientationUpright;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return TextOrientationVerticalRight;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EPointerEvents e)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(EPointerEvents e)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case PE_NONE:
         m_value.valueID = CSSValueNone;
         break;
     case PE_STROKE:
         m_value.valueID = CSSValueStroke;
         break;
@@ skipping 23 matching lines @@
         break;
     case PE_BOUNDINGBOX:
         m_value.valueID = CSSValueBoundingBox;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EPointerEvents() const
 {
     ASSERT(isValueID());
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     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 10 matching lines @@
     case CSSValueBoundingBox:
         return PE_BOUNDINGBOX;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return PE_ALL;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontDescription::Kerning kerning)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(FontDescription::Kerning kerning)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (kerning) {
     case FontDescription::AutoKerning:
         m_value.valueID = CSSValueAuto;
         return;
     case FontDescription::NormalKerning:
         m_value.valueID = CSSValueNormal;
         return;
     case FontDescription::NoneKerning:
         m_value.valueID = CSSValueNone;
         return;
     }
 
     ASSERT_NOT_REACHED();
     m_value.valueID = CSSValueAuto;
 }
 
 template<> inline CSSPrimitiveValue::operator FontDescription::Kerning() const
 {
     ASSERT(isValueID());
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueAuto:
         return FontDescription::AutoKerning;
     case CSSValueNormal:
         return FontDescription::NormalKerning;
     case CSSValueNone:
         return FontDescription::NoneKerning;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return FontDescription::AutoKerning;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ObjectFit fit)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(ObjectFit fit)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (fit) {
     case ObjectFitFill:
         m_value.valueID = CSSValueFill;
         break;
     case ObjectFitContain:
         m_value.valueID = CSSValueContain;
         break;
     case ObjectFitCover:
         m_value.valueID = CSSValueCover;
         break;
     case ObjectFitNone:
         m_value.valueID = CSSValueNone;
         break;
     case ObjectFitScaleDown:
         m_value.valueID = CSSValueScaleDown;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator ObjectFit() const
 {
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueFill:
         return ObjectFitFill;
     case CSSValueContain:
         return ObjectFitContain;
     case CSSValueCover:
         return ObjectFitCover;
     case CSSValueNone:
         return ObjectFitNone;
     case CSSValueScaleDown:
         return ObjectFitScaleDown;
     default:
         ASSERT_NOT_REACHED();
         return ObjectFitFill;
     }
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFillSizeType fillSize)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(EFillSizeType fillSize)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (fillSize) {
     case Contain:
         m_value.valueID = CSSValueContain;
         break;
     case Cover:
         m_value.valueID = CSSValueCover;
         break;
     case SizeNone:
         m_value.valueID = CSSValueNone;
         break;
     case SizeLength:
     default:
         ASSERT_NOT_REACHED();
     }
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontSmoothingMode smoothing)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(FontSmoothingMode smoothing)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (smoothing) {
     case AutoSmoothing:
         m_value.valueID = CSSValueAuto;
         return;
     case NoSmoothing:
         m_value.valueID = CSSValueNone;
         return;
     case Antialiased:
         m_value.valueID = CSSValueAntialiased;
         return;
     case SubpixelAntialiased:
         m_value.valueID = CSSValueSubpixelAntialiased;
         return;
     }
 
     ASSERT_NOT_REACHED();
     m_value.valueID = CSSValueAuto;
 }
 
 template<> inline CSSPrimitiveValue::operator FontSmoothingMode() const
 {
     ASSERT(isValueID());
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueAuto:
         return AutoSmoothing;
     case CSSValueNone:
         return NoSmoothing;
     case CSSValueAntialiased:
         return Antialiased;
     case CSSValueSubpixelAntialiased:
         return SubpixelAntialiased;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return AutoSmoothing;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontWeight weight)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(FontWeight weight)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (weight) {
     case FontWeight900:
         m_value.valueID = CSSValue900;
         return;
     case FontWeight800:
         m_value.valueID = CSSValue800;
         return;
@@ skipping 20 matching lines @@
         return;
     }
 
     ASSERT_NOT_REACHED();
     m_value.valueID = CSSValueNormal;
 }
 
 template<> inline CSSPrimitiveValue::operator FontWeight() const
 {
     ASSERT(isValueID());
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueBold:
         return FontWeightBold;
     case CSSValueNormal:
         return FontWeightNormal;
     case CSSValue900:
         return FontWeight900;
     case CSSValue800:
         return FontWeight800;
     case CSSValue700:
         return FontWeight700;
@@ skipping 10 matching lines @@
     case CSSValue100:
         return FontWeight100;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return FontWeightNormal;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontStyle italic)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(FontStyle italic)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (italic) {
     case FontStyleNormal:
         m_value.valueID = CSSValueNormal;
         return;
     case FontStyleItalic:
         m_value.valueID = CSSValueItalic;
         return;
     }
 
     ASSERT_NOT_REACHED();
     m_value.valueID = CSSValueNormal;
 }
 
 template<> inline CSSPrimitiveValue::operator FontStyle() const
 {
     ASSERT(isValueID());
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     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();
     return FontStyleNormal;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontStretch stretch)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(FontStretch stretch)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (stretch) {
     case FontStretchUltraCondensed:
         m_value.valueID = CSSValueUltraCondensed;
         return;
     case FontStretchExtraCondensed:
         m_value.valueID = CSSValueExtraCondensed;
         return;
@@ skipping 20 matching lines @@
         return;
     }
 
     ASSERT_NOT_REACHED();
     m_value.valueID = CSSValueNormal;
 }
 
 template<> inline CSSPrimitiveValue::operator FontStretch() const
 {
     ASSERT(isValueID());
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueUltraCondensed:
         return FontStretchUltraCondensed;
     case CSSValueExtraCondensed:
         return FontStretchExtraCondensed;
     case CSSValueCondensed:
         return FontStretchCondensed;
     case CSSValueSemiCondensed:
         return FontStretchSemiCondensed;
     case CSSValueNormal:
         return FontStretchNormal;
     case CSSValueSemiExpanded:
         return FontStretchSemiExpanded;
     case CSSValueExpanded:
         return FontStretchExpanded;
     case CSSValueExtraExpanded:
         return FontStretchExtraExpanded;
     case CSSValueUltraExpanded:
         return FontStretchUltraExpanded;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return FontStretchNormal;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontVariant smallCaps)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(FontVariant smallCaps)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (smallCaps) {
     case FontVariantNormal:
         m_value.valueID = CSSValueNormal;
         return;
     case FontVariantSmallCaps:
         m_value.valueID = CSSValueSmallCaps;
         return;
     }
 
     ASSERT_NOT_REACHED();
     m_value.valueID = CSSValueNormal;
 }
 
 template<> inline CSSPrimitiveValue::operator FontVariant() const
 {
     ASSERT(isValueID());
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueSmallCaps:
         return FontVariantSmallCaps;
     case CSSValueNormal:
         return FontVariantNormal;
     default:
         break;
     }
     ASSERT_NOT_REACHED();
     return FontVariantNormal;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextRenderingMode e)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(TextRenderingMode e)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case AutoTextRendering:
         m_value.valueID = CSSValueAuto;
         break;
     case OptimizeSpeed:
         m_value.valueID = CSSValueOptimizeSpeed;
         break;
     case OptimizeLegibility:
         m_value.valueID = CSSValueOptimizeLegibility;
         break;
     case GeometricPrecision:
         m_value.valueID = CSSValueGeometricPrecision;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator TextRenderingMode() const
 {
     ASSERT(isValueID());
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueAuto:
         return AutoTextRendering;
     case CSSValueOptimizeSpeed:
         return OptimizeSpeed;
     case CSSValueOptimizeLegibility:
         return OptimizeLegibility;
     case CSSValueGeometricPrecision:
         return GeometricPrecision;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return AutoTextRendering;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ESpeak e)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(ESpeak e)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case SpeakNone:
         m_value.valueID = CSSValueNone;
         break;
     case SpeakNormal:
         m_value.valueID = CSSValueNormal;
         break;
     case SpeakSpellOut:
         m_value.valueID = CSSValueSpellOut;
         break;
     case SpeakDigits:
         m_value.valueID = CSSValueDigits;
         break;
     case SpeakLiteralPunctuation:
         m_value.valueID = CSSValueLiteralPunctuation;
         break;
     case SpeakNoPunctuation:
         m_value.valueID = CSSValueNoPunctuation;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator Order() const
 {
     ASSERT(isValueID());
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueLogical:
         return LogicalOrder;
     case CSSValueVisual:
         return VisualOrder;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return LogicalOrder;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(Order e)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(Order e)
     : CSSValueObject(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 (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueNone:
         return SpeakNone;
     case CSSValueNormal:
         return SpeakNormal;
     case CSSValueSpellOut:
         return SpeakSpellOut;
     case CSSValueDigits:
         return SpeakDigits;
     case CSSValueLiteralPunctuation:
         return SpeakLiteralPunctuation;
     case CSSValueNoPunctuation:
         return SpeakNoPunctuation;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return SpeakNormal;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(WebBlendMode blendMode)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(WebBlendMode blendMode)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (blendMode) {
     case WebBlendModeNormal:
         m_value.valueID = CSSValueNormal;
         break;
     case WebBlendModeMultiply:
         m_value.valueID = CSSValueMultiply;
         break;
@@ skipping 38 matching lines @@
         break;
     case WebBlendModeLuminosity:
         m_value.valueID = CSSValueLuminosity;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator WebBlendMode() const
 {
     ASSERT(isValueID());
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueNormal:
         return WebBlendModeNormal;
     case CSSValueMultiply:
         return WebBlendModeMultiply;
     case CSSValueScreen:
         return WebBlendModeScreen;
     case CSSValueOverlay:
         return WebBlendModeOverlay;
     case CSSValueDarken:
         return WebBlendModeDarken;
@@ skipping 20 matching lines @@
     case CSSValueLuminosity:
         return WebBlendModeLuminosity;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return WebBlendModeNormal;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineCap e)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(LineCap e)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case ButtCap:
         m_value.valueID = CSSValueButt;
         break;
     case RoundCap:
         m_value.valueID = CSSValueRound;
         break;
     case SquareCap:
         m_value.valueID = CSSValueSquare;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator LineCap() const
 {
     ASSERT(isValueID());
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueButt:
         return ButtCap;
     case CSSValueRound:
         return RoundCap;
     case CSSValueSquare:
         return SquareCap;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return ButtCap;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineJoin e)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(LineJoin e)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case MiterJoin:
         m_value.valueID = CSSValueMiter;
         break;
     case RoundJoin:
         m_value.valueID = CSSValueRound;
         break;
     case BevelJoin:
         m_value.valueID = CSSValueBevel;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator LineJoin() const
 {
     ASSERT(isValueID());
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueMiter:
         return MiterJoin;
     case CSSValueRound:
         return RoundJoin;
     case CSSValueBevel:
         return BevelJoin;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return MiterJoin;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(WindRule e)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(WindRule e)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case RULE_NONZERO:
         m_value.valueID = CSSValueNonzero;
         break;
     case RULE_EVENODD:
         m_value.valueID = CSSValueEvenodd;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator WindRule() const
 {
     ASSERT(isValueID());
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueNonzero:
         return RULE_NONZERO;
     case CSSValueEvenodd:
         return RULE_EVENODD;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return RULE_NONZERO;
 }
 
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EAlignmentBaseline e)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(EAlignmentBaseline e)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case AB_AUTO:
         m_value.valueID = CSSValueAuto;
         break;
     case AB_BASELINE:
         m_value.valueID = CSSValueBaseline;
         break;
@@ skipping 26 matching lines @@
         break;
     case AB_MATHEMATICAL:
         m_value.valueID = CSSValueMathematical;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EAlignmentBaseline() const
 {
     ASSERT(isValueID());
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     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 12 matching lines @@
     case CSSValueMathematical:
         return AB_MATHEMATICAL;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return AB_AUTO;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBorderCollapse e)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(EBorderCollapse e)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case BSEPARATE:
         m_value.valueID = CSSValueSeparate;
         break;
     case BCOLLAPSE:
         m_value.valueID = CSSValueCollapse;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EBorderCollapse() const
 {
     ASSERT(isValueID());
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueSeparate:
         return BSEPARATE;
     case CSSValueCollapse:
         return BCOLLAPSE;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return BSEPARATE;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EImageRendering e)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(EImageRendering e)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case ImageRenderingAuto:
         m_value.valueID = CSSValueAuto;
         break;
     case ImageRenderingOptimizeSpeed:
         m_value.valueID = CSSValueOptimizeSpeed;
         break;
     case ImageRenderingOptimizeQuality:
         m_value.valueID = CSSValueOptimizeQuality;
         break;
     case ImageRenderingPixelated:
         m_value.valueID = CSSValuePixelated;
         break;
     case ImageRenderingOptimizeContrast:
         m_value.valueID = CSSValueWebkitOptimizeContrast;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EImageRendering() const
 {
     ASSERT(isValueID());
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueAuto:
         return ImageRenderingAuto;
     case CSSValueOptimizeSpeed:
         return ImageRenderingOptimizeSpeed;
     case CSSValueOptimizeQuality:
         return ImageRenderingOptimizeQuality;
     case CSSValuePixelated:
         return ImageRenderingPixelated;
     case CSSValueWebkitOptimizeContrast:
         return ImageRenderingOptimizeContrast;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return ImageRenderingAuto;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETransformStyle3D e)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(ETransformStyle3D e)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case TransformStyle3DFlat:
         m_value.valueID = CSSValueFlat;
         break;
     case TransformStyle3DPreserve3D:
         m_value.valueID = CSSValuePreserve3d;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator ETransformStyle3D() const
 {
     ASSERT(isValueID());
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueFlat:
         return TransformStyle3DFlat;
     case CSSValuePreserve3d:
         return TransformStyle3DPreserve3D;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return TransformStyle3DFlat;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBufferedRendering e)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(EBufferedRendering e)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case BR_AUTO:
         m_value.valueID = CSSValueAuto;
         break;
     case BR_DYNAMIC:
         m_value.valueID = CSSValueDynamic;
         break;
     case BR_STATIC:
         m_value.valueID = CSSValueStatic;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EBufferedRendering() const
 {
     ASSERT(isValueID());
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueAuto:
         return BR_AUTO;
     case CSSValueDynamic:
         return BR_DYNAMIC;
     case CSSValueStatic:
         return BR_STATIC;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return BR_AUTO;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EColorInterpolation e)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(EColorInterpolation e)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case CI_AUTO:
         m_value.valueID = CSSValueAuto;
         break;
     case CI_SRGB:
         m_value.valueID = CSSValueSRGB;
         break;
     case CI_LINEARRGB:
         m_value.valueID = CSSValueLinearRGB;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EColorInterpolation() const
 {
     ASSERT(isValueID());
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueSRGB:
         return CI_SRGB;
     case CSSValueLinearRGB:
         return CI_LINEARRGB;
     case CSSValueAuto:
         return CI_AUTO;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return CI_AUTO;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EColorRendering e)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(EColorRendering e)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case CR_AUTO:
         m_value.valueID = CSSValueAuto;
         break;
     case CR_OPTIMIZESPEED:
         m_value.valueID = CSSValueOptimizeSpeed;
         break;
     case CR_OPTIMIZEQUALITY:
         m_value.valueID = CSSValueOptimizeQuality;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EColorRendering() const
 {
     ASSERT(isValueID());
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueOptimizeSpeed:
         return CR_OPTIMIZESPEED;
     case CSSValueOptimizeQuality:
         return CR_OPTIMIZEQUALITY;
     case CSSValueAuto:
         return CR_AUTO;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return CR_AUTO;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EDominantBaseline e)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(EDominantBaseline e)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case DB_AUTO:
         m_value.valueID = CSSValueAuto;
         break;
     case DB_USE_SCRIPT:
         m_value.valueID = CSSValueUseScript;
         break;
@@ skipping 26 matching lines @@
         break;
     case DB_MATHEMATICAL:
         m_value.valueID = CSSValueMathematical;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EDominantBaseline() const
 {
     ASSERT(isValueID());
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     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 12 matching lines @@
     case CSSValueTextBeforeEdge:
         return DB_TEXT_BEFORE_EDGE;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return DB_AUTO;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EShapeRendering e)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(EShapeRendering e)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case SR_AUTO:
         m_value.valueID = CSSValueAuto;
         break;
     case SR_OPTIMIZESPEED:
         m_value.valueID = CSSValueOptimizeSpeed;
         break;
     case SR_CRISPEDGES:
         m_value.valueID = CSSValueCrispEdges;
         break;
     case SR_GEOMETRICPRECISION:
         m_value.valueID = CSSValueGeometricPrecision;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EShapeRendering() const
 {
     ASSERT(isValueID());
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueAuto:
         return SR_AUTO;
     case CSSValueOptimizeSpeed:
         return SR_OPTIMIZESPEED;
     case CSSValueCrispEdges:
         return SR_CRISPEDGES;
     case CSSValueGeometricPrecision:
         return SR_GEOMETRICPRECISION;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return SR_AUTO;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETextAnchor e)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(ETextAnchor e)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case TA_START:
         m_value.valueID = CSSValueStart;
         break;
     case TA_MIDDLE:
         m_value.valueID = CSSValueMiddle;
         break;
     case TA_END:
         m_value.valueID = CSSValueEnd;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator ETextAnchor() const
 {
     ASSERT(isValueID());
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueStart:
         return TA_START;
     case CSSValueMiddle:
         return TA_MIDDLE;
     case CSSValueEnd:
         return TA_END;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return TA_START;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(SVGWritingMode e)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(SVGWritingMode e)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case WM_LRTB:
         m_value.valueID = CSSValueLrTb;
         break;
     case WM_LR:
         m_value.valueID = CSSValueLr;
         break;
     case WM_RLTB:
         m_value.valueID = CSSValueRlTb;
         break;
     case WM_RL:
         m_value.valueID = CSSValueRl;
         break;
     case WM_TBRL:
         m_value.valueID = CSSValueTbRl;
         break;
     case WM_TB:
         m_value.valueID = CSSValueTb;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator SVGWritingMode() const
 {
     ASSERT(isValueID());
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     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;
     case CSSValueTb:
         return WM_TB;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return WM_LRTB;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EVectorEffect e)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(EVectorEffect e)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case VE_NONE:
         m_value.valueID = CSSValueNone;
         break;
     case VE_NON_SCALING_STROKE:
         m_value.valueID = CSSValueNonScalingStroke;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EVectorEffect() const
 {
     ASSERT(isValueID());
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueNone:
         return VE_NONE;
     case CSSValueNonScalingStroke:
         return VE_NON_SCALING_STROKE;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return VE_NONE;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EPaintOrderType e)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(EPaintOrderType e)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case PT_FILL:
         m_value.valueID = CSSValueFill;
         break;
     case PT_STROKE:
         m_value.valueID = CSSValueStroke;
         break;
     case PT_MARKERS:
         m_value.valueID = CSSValueMarkers;
         break;
     default:
         ASSERT_NOT_REACHED();
         m_value.valueID = CSSValueFill;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EPaintOrderType() const
 {
     ASSERT(isValueID());
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueFill:
         return PT_FILL;
     case CSSValueStroke:
         return PT_STROKE;
     case CSSValueMarkers:
         return PT_MARKERS;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return PT_NONE;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EMaskType e)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(EMaskType e)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case MT_LUMINANCE:
         m_value.valueID = CSSValueLuminance;
         break;
     case MT_ALPHA:
         m_value.valueID = CSSValueAlpha;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EMaskType() const
 {
     ASSERT(isValueID());
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     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 (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueNone:
         return TouchActionNone;
     case CSSValueAuto:
         return TouchActionAuto;
     case CSSValuePanLeft:
         return TouchActionPanLeft;
     case CSSValuePanRight:
         return TouchActionPanRight;
     case CSSValuePanX:
         return TouchActionPanX;
     case CSSValuePanUp:
         return TouchActionPanUp;
     case CSSValuePanDown:
         return TouchActionPanDown;
     case CSSValuePanY:
         return TouchActionPanY;
     case CSSValueManipulation:
         return TouchActionPanX | TouchActionPanY | TouchActionPinchZoom;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return TouchActionNone;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EIsolation i)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(EIsolation i)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (i) {
     case IsolationAuto:
         m_value.valueID = CSSValueAuto;
         break;
     case IsolationIsolate:
         m_value.valueID = CSSValueIsolate;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator EIsolation() const
 {
     ASSERT(isValueID());
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueAuto:
         return IsolationAuto;
     case CSSValueIsolate:
         return IsolationIsolate;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return IsolationAuto;
 }
 
 template<> inline CSSPrimitiveValue::operator WebScrollBlocksOn() const
 {
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueNone:
         return WebScrollBlocksOnNone;
     case CSSValueStartTouch:
         return WebScrollBlocksOnStartTouch;
     case CSSValueWheelEvent:
         return WebScrollBlocksOnWheelEvent;
     case CSSValueScrollEvent:
         return WebScrollBlocksOnScrollEvent;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return WebScrollBlocksOnNone;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(CSSBoxType cssBox)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(CSSBoxType cssBox)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (cssBox) {
     case MarginBox:
         m_value.valueID = CSSValueMarginBox;
         break;
     case BorderBox:
         m_value.valueID = CSSValueBorderBox;
         break;
@@ skipping 20 matching lines @@
         return PaddingBox;
     case CSSValueContentBox:
         return ContentBox;
     default:
         break;
     }
     ASSERT_NOT_REACHED();
     return ContentBox;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ItemPosition itemPosition)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(ItemPosition itemPosition)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (itemPosition) {
     case ItemPositionAuto:
         m_value.valueID = CSSValueAuto;
         break;
     case ItemPositionStretch:
         m_value.valueID = CSSValueStretch;
         break;
@@ skipping 28 matching lines @@
         m_value.valueID = CSSValueLeft;
         break;
     case ItemPositionRight:
         m_value.valueID = CSSValueRight;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator ItemPosition() const
 {
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueAuto:
         return ItemPositionAuto;
     case CSSValueStretch:
         return ItemPositionStretch;
     case CSSValueBaseline:
         return ItemPositionBaseline;
     case CSSValueLastBaseline:
         return ItemPositionLastBaseline;
     case CSSValueCenter:
         return ItemPositionCenter;
@@ skipping 13 matching lines @@
         return ItemPositionLeft;
     case CSSValueRight:
         return ItemPositionRight;
     default:
         break;
     }
     ASSERT_NOT_REACHED();
     return ItemPositionAuto;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ContentPosition contentPosition)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(ContentPosition contentPosition)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (contentPosition) {
     case ContentPositionAuto:
         m_value.valueID = CSSValueAuto;
         break;
     case ContentPositionBaseline:
         m_value.valueID = CSSValueBaseline;
         break;
@@ skipping 19 matching lines @@
         m_value.valueID = CSSValueLeft;
         break;
     case ContentPositionRight:
         m_value.valueID = CSSValueRight;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator ContentPosition() const
 {
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueAuto:
         return ContentPositionAuto;
     case CSSValueBaseline:
         return ContentPositionBaseline;
     case CSSValueLastBaseline:
         return ContentPositionLastBaseline;
     case CSSValueCenter:
         return ContentPositionCenter;
     case CSSValueStart:
         return ContentPositionStart;
     case CSSValueEnd:
         return ContentPositionEnd;
     case CSSValueFlexStart:
         return ContentPositionFlexStart;
     case CSSValueFlexEnd:
         return ContentPositionFlexEnd;
     case CSSValueLeft:
         return ContentPositionLeft;
     case CSSValueRight:
         return ContentPositionRight;
     default:
         break;
     }
     ASSERT_NOT_REACHED();
     return ContentPositionAuto;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ContentDistributionType contentDistribution)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(ContentDistributionType contentDistribution)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (contentDistribution) {
     case ContentDistributionDefault:
         m_value.valueID = CSSValueDefault;
         break;
     case ContentDistributionSpaceBetween:
         m_value.valueID = CSSValueSpaceBetween;
         break;
     case ContentDistributionSpaceAround:
         m_value.valueID = CSSValueSpaceAround;
         break;
     case ContentDistributionSpaceEvenly:
         m_value.valueID = CSSValueSpaceEvenly;
         break;
     case ContentDistributionStretch:
         m_value.valueID = CSSValueStretch;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator ContentDistributionType() const
 {
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueSpaceBetween:
         return ContentDistributionSpaceBetween;
     case CSSValueSpaceAround:
         return ContentDistributionSpaceAround;
     case CSSValueSpaceEvenly:
         return ContentDistributionSpaceEvenly;
     case CSSValueStretch:
         return ContentDistributionStretch;
     default:
         break;
     }
     ASSERT_NOT_REACHED();
     return ContentDistributionStretch;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(OverflowAlignment overflowAlignment)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(OverflowAlignment overflowAlignment)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (overflowAlignment) {
     case OverflowAlignmentDefault:
         m_value.valueID = CSSValueDefault;
         break;
     case OverflowAlignmentTrue:
         m_value.valueID = CSSValueTrue;
         break;
     case OverflowAlignmentSafe:
         m_value.valueID = CSSValueSafe;
         break;
     }
 }
 
 template<> inline CSSPrimitiveValue::operator OverflowAlignment() const
 {
-    switch (m_value.valueID) {
+    switch (value().valueID) {
     case CSSValueTrue:
         return OverflowAlignmentTrue;
     case CSSValueSafe:
         return OverflowAlignmentSafe;
     default:
         break;
     }
     ASSERT_NOT_REACHED();
     return OverflowAlignmentTrue;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ScrollBehavior behavior)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(ScrollBehavior behavior)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (behavior) {
     case ScrollBehaviorAuto:
         m_value.valueID = CSSValueAuto;
         break;
     case ScrollBehaviorSmooth:
         m_value.valueID = CSSValueSmooth;
         break;
@@ skipping 11 matching lines @@
         return ScrollBehaviorAuto;
     case CSSValueSmooth:
         return ScrollBehaviorSmooth;
     default:
         break;
     }
     ASSERT_NOT_REACHED();
     return ScrollBehaviorAuto;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ScrollSnapType snapType)
+template<> inline CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(ScrollSnapType snapType)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (snapType) {
     case ScrollSnapTypeNone:
         m_value.valueID = CSSValueNone;
         break;
     case ScrollSnapTypeMandatory:
         m_value.valueID = CSSValueMandatory;
         break;
@@ skipping 15 matching lines @@
     default:
         break;
     }
     ASSERT_NOT_REACHED();
     return ScrollSnapTypeNone;
 }
 
 } // namespace blink
 
 #endif