CSSValue Immediates: Change CSSValue to an object instead of a pointer

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 39 matching lines @@
 #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)
-    : CSSValue(PrimitiveClass)
+    : 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)
-    : CSSValue(PrimitiveClass)
+    : 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)
-    : CSSValue(PrimitiveClass)
+    : 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)
-    : CSSValue(PrimitiveClass)
+    : 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 (m_primitiveUnitType == CSS_PERCENTAGE)
         return LineClampValue(clampTo<int>(m_value.num), LineClampPercentage);
 
     ASSERT_NOT_REACHED();
     return LineClampValue();
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(CSSReflectionDirection e)
-    : CSSValue(PrimitiveClass)
+    : 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:
@@ skipping 18 matching lines @@
         return ReflectionRight;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return ReflectionBelow;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ColumnFill columnFill)
-    : CSSValue(PrimitiveClass)
+    : 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)
             return ColumnFillBalance;
         if (m_value.valueID == CSSValueAuto)
             return ColumnFillAuto;
     }
     ASSERT_NOT_REACHED();
     return ColumnFillBalance;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ColumnSpan columnSpan)
-    : CSSValue(PrimitiveClass)
+    : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (columnSpan) {
     case ColumnSpanAll:
         m_value.valueID = CSSValueAll;
         break;
     case ColumnSpanNone:
         m_value.valueID = CSSValueNone;
         break;
     }
@@ skipping 14 matching lines @@
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return ColumnSpanNone;
 }
 
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(PrintColorAdjust value)
-    : CSSValue(PrimitiveClass)
+    : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (value) {
     case PrintColorAdjustExact:
         m_value.valueID = CSSValueExact;
         break;
     case PrintColorAdjustEconomy:
         m_value.valueID = CSSValueEconomy;
         break;
     }
@@ skipping 10 matching lines @@
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return PrintColorAdjustEconomy;
 }
 
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBorderStyle e)
-    : CSSValue(PrimitiveClass)
+    : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case BNONE:
         m_value.valueID = CSSValueNone;
         break;
     case BHIDDEN:
         m_value.valueID = CSSValueHidden;
         break;
     case INSET:
@@ skipping 32 matching lines @@
 }
 
 template<> inline CSSPrimitiveValue::operator OutlineIsAuto() const
 {
     if (m_value.valueID == CSSValueAuto)
         return AUTO_ON;
     return AUTO_OFF;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(CompositeOperator e)
-    : CSSValue(PrimitiveClass)
+    : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case CompositeClear:
         m_value.valueID = CSSValueClear;
         break;
     case CompositeCopy:
         m_value.valueID = CSSValueCopy;
         break;
     case CompositeSourceOver:
@@ skipping 62 matching lines @@
         return CompositePlusLighter;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return CompositeClear;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ControlPart e)
-    : CSSValue(PrimitiveClass)
+    : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case NoControlPart:
         m_value.valueID = CSSValueNone;
         break;
     case CheckboxPart:
         m_value.valueID = CSSValueCheckbox;
         break;
     case RadioPart:
@@ skipping 151 matching lines @@
 
 template<> inline CSSPrimitiveValue::operator ControlPart() const
 {
     ASSERT(isValueID());
     if (m_value.valueID == CSSValueNone)
         return NoControlPart;
     return ControlPart(m_value.valueID - CSSValueCheckbox + 1);
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBackfaceVisibility e)
-    : CSSValue(PrimitiveClass)
+    : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case BackfaceVisibilityVisible:
         m_value.valueID = CSSValueVisible;
         break;
     case BackfaceVisibilityHidden:
         m_value.valueID = CSSValueHidden;
         break;
     }
@@ skipping 10 matching lines @@
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return BackfaceVisibilityHidden;
 }
 
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFillAttachment e)
-    : CSSValue(PrimitiveClass)
+    : 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:
@@ skipping 14 matching lines @@
         return FixedBackgroundAttachment;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return ScrollBackgroundAttachment;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFillBox e)
-    : CSSValue(PrimitiveClass)
+    : 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:
@@ skipping 23 matching lines @@
         return TextFillBox;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return BorderFillBox;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFillRepeat e)
-    : CSSValue(PrimitiveClass)
+    : 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:
@@ skipping 19 matching lines @@
         return SpaceFill;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return RepeatFill;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxPack e)
-    : CSSValue(PrimitiveClass)
+    : 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:
@@ skipping 19 matching lines @@
         return Justify;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return Justify;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxAlignment e)
-    : CSSValue(PrimitiveClass)
+    : 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:
@@ skipping 24 matching lines @@
         return BBASELINE;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return BSTRETCH;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxDecorationBreak e)
-    : CSSValue(PrimitiveClass)
+    : 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) {
     case CSSValueSlice:
         return DSLICE;
     case CSSValueClone:
         return DCLONE;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return DSLICE;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(BackgroundEdgeOrigin e)
-    : CSSValue(PrimitiveClass)
+    : 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:
@@ skipping 19 matching lines @@
         return LeftEdge;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return TopEdge;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxSizing e)
-    : CSSValue(PrimitiveClass)
+    : 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) {
     case CSSValueBorderBox:
         return BORDER_BOX;
     case CSSValueContentBox:
         return CONTENT_BOX;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return BORDER_BOX;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxDirection e)
-    : CSSValue(PrimitiveClass)
+    : 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) {
     case CSSValueNormal:
         return BNORMAL;
     case CSSValueReverse:
         return BREVERSE;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return BNORMAL;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxLines e)
-    : CSSValue(PrimitiveClass)
+    : 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) {
     case CSSValueSingle:
         return SINGLE;
     case CSSValueMultiple:
         return MULTIPLE;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return SINGLE;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxOrient e)
-    : CSSValue(PrimitiveClass)
+    : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case HORIZONTAL:
         m_value.valueID = CSSValueHorizontal;
         break;
     case VERTICAL:
         m_value.valueID = CSSValueVertical;
         break;
     }
@@ skipping 11 matching lines @@
         return VERTICAL;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return HORIZONTAL;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ECaptionSide e)
-    : CSSValue(PrimitiveClass)
+    : 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:
@@ skipping 19 matching lines @@
         return CAPBOTTOM;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return CAPTOP;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EClear e)
-    : CSSValue(PrimitiveClass)
+    : 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:
@@ skipping 19 matching lines @@
         return CBOTH;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return CNONE;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ECursor e)
-    : CSSValue(PrimitiveClass)
+    : 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;
     case CURSOR_DEFAULT:
@@ skipping 112 matching lines @@
     case CSSValueWebkitZoomOut:
         return CURSOR_ZOOM_OUT;
     case CSSValueNone:
         return CURSOR_NONE;
     default:
         return static_cast<ECursor>(m_value.valueID - CSSValueAuto);
     }
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EDisplay e)
-    : CSSValue(PrimitiveClass)
+    : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case INLINE:
         m_value.valueID = CSSValueInline;
         break;
     case BLOCK:
         m_value.valueID = CSSValueBlock;
         break;
     case LIST_ITEM:
@@ skipping 66 matching lines @@
         return FLEX;
     if (m_value.valueID == CSSValueWebkitInlineFlex)
         return INLINE_FLEX;
 
     EDisplay display = static_cast<EDisplay>(m_value.valueID - CSSValueInline);
     ASSERT(display >= INLINE && display <= NONE);
     return display;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EEmptyCell e)
-    : CSSValue(PrimitiveClass)
+    : 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) {
     case CSSValueShow:
         return SHOW;
     case CSSValueHide:
         return HIDE;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return SHOW;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFlexDirection e)
-    : CSSValue(PrimitiveClass)
+    : 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:
@@ skipping 19 matching lines @@
         return FlowColumnReverse;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return FlowRow;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFlexWrap e)
-    : CSSValue(PrimitiveClass)
+    : 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:
@@ skipping 14 matching lines @@
         return FlexWrapReverse;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return FlexNoWrap;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFloat e)
-    : CSSValue(PrimitiveClass)
+    : 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:
@@ skipping 14 matching lines @@
         return NoFloat;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return NoFloat;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineBreak e)
-    : CSSValue(PrimitiveClass)
+    : 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:
@@ skipping 24 matching lines @@
         return LineBreakAfterWhiteSpace;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return LineBreakAuto;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EListStylePosition e)
-    : CSSValue(PrimitiveClass)
+    : 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) {
     case CSSValueOutside:
         return OUTSIDE;
     case CSSValueInside:
         return INSIDE;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return OUTSIDE;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EListStyleType e)
-    : CSSValue(PrimitiveClass)
+    : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case Afar:
         m_value.valueID = CSSValueAfar;
         break;
     case Amharic:
         m_value.valueID = CSSValueAmharic;
         break;
     case AmharicAbegede:
@@ skipping 241 matching lines @@
     ASSERT(isValueID());
     switch (m_value.valueID) {
     case CSSValueNone:
         return NoneListStyle;
     default:
         return static_cast<EListStyleType>(m_value.valueID - CSSValueDisc);
     }
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EMarginCollapse e)
-    : CSSValue(PrimitiveClass)
+    : 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:
@@ skipping 14 matching lines @@
         return MDISCARD;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return MCOLLAPSE;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EOverflow e)
-    : CSSValue(PrimitiveClass)
+    : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case OVISIBLE:
         m_value.valueID = CSSValueVisible;
         break;
     case OHIDDEN:
         m_value.valueID = CSSValueHidden;
         break;
     case OSCROLL:
@@ skipping 34 matching lines @@
         return OPAGEDY;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return OVISIBLE;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EPageBreak e)
-    : CSSValue(PrimitiveClass)
+    : 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:
@@ skipping 16 matching lines @@
         return PBAVOID;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return PBAUTO;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EPosition e)
-    : CSSValue(PrimitiveClass)
+    : 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:
@@ skipping 19 matching lines @@
         return FixedPosition;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return StaticPosition;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EResize e)
-    : CSSValue(PrimitiveClass)
+    : 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:
@@ skipping 22 matching lines @@
         return RESIZE_NONE;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return RESIZE_NONE;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETableLayout e)
-    : CSSValue(PrimitiveClass)
+    : 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) {
     case CSSValueFixed:
         return TFIXED;
     case CSSValueAuto:
         return TAUTO;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return TAUTO;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETextAlign e)
-    : CSSValue(PrimitiveClass)
+    : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case TASTART:
         m_value.valueID = CSSValueStart;
         break;
     case TAEND:
         m_value.valueID = CSSValueEnd;
         break;
     case LEFT:
@@ skipping 28 matching lines @@
     case CSSValueStart:
         return TASTART;
     case CSSValueEnd:
         return TAEND;
     default:
         return static_cast<ETextAlign>(m_value.valueID - CSSValueLeft);
     }
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextAlignLast e)
-    : CSSValue(PrimitiveClass)
+    : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case TextAlignLastStart:
         m_value.valueID = CSSValueStart;
         break;
     case TextAlignLastEnd:
         m_value.valueID = CSSValueEnd;
         break;
     case TextAlignLastLeft:
@@ skipping 34 matching lines @@
         return TextAlignLastJustify;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return TextAlignLastAuto;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextJustify e)
-    : CSSValue(PrimitiveClass)
+    : 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:
@@ skipping 62 matching lines @@
         return TextDecorationStyleWavy;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return TextDecorationStyleSolid;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextUnderlinePosition e)
-    : CSSValue(PrimitiveClass)
+    : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case TextUnderlinePositionAuto:
         m_value.valueID = CSSValueAuto;
         break;
     case TextUnderlinePositionUnder:
         m_value.valueID = CSSValueUnder;
         break;
     }
@@ skipping 13 matching lines @@
         break;
     }
 
     // FIXME: Implement support for 'under left' and 'under right' values.
 
     ASSERT_NOT_REACHED();
     return TextUnderlinePositionAuto;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETextSecurity e)
-    : CSSValue(PrimitiveClass)
+    : 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:
@@ skipping 19 matching lines @@
         return TSSQUARE;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return TSNONE;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETextTransform e)
-    : CSSValue(PrimitiveClass)
+    : 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:
@@ skipping 19 matching lines @@
         return TTNONE;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return TTNONE;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUnicodeBidi e)
-    : CSSValue(PrimitiveClass)
+    : 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:
@@ skipping 29 matching lines @@
         return Plaintext;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return UBNormal;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUserDrag e)
-    : CSSValue(PrimitiveClass)
+    : 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:
@@ skipping 16 matching lines @@
         return DRAG_ELEMENT;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return DRAG_AUTO;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUserModify e)
-    : CSSValue(PrimitiveClass)
+    : 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:
@@ skipping 14 matching lines @@
         return READ_WRITE_PLAINTEXT_ONLY;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return READ_ONLY;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUserSelect e)
-    : CSSValue(PrimitiveClass)
+    : 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:
@@ skipping 16 matching lines @@
         return SELECT_ALL;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return SELECT_TEXT;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EVerticalAlign a)
-    : CSSValue(PrimitiveClass)
+    : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (a) {
     case TOP:
         m_value.valueID = CSSValueTop;
         break;
     case BOTTOM:
         m_value.valueID = CSSValueBottom;
         break;
     case MIDDLE:
@@ skipping 46 matching lines @@
         return BASELINE_MIDDLE;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return TOP;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EVisibility e)
-    : CSSValue(PrimitiveClass)
+    : 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:
@@ skipping 14 matching lines @@
         return COLLAPSE;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return VISIBLE;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EWhiteSpace e)
-    : CSSValue(PrimitiveClass)
+    : 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:
@@ skipping 29 matching lines @@
         return NORMAL;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return NORMAL;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EWordBreak e)
-    : CSSValue(PrimitiveClass)
+    : 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:
@@ skipping 19 matching lines @@
         return KeepAllWordBreak;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return NormalWordBreak;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EOverflowWrap e)
-    : CSSValue(PrimitiveClass)
+    : 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) {
     case CSSValueBreakWord:
         return BreakOverflowWrap;
     case CSSValueNormal:
         return NormalOverflowWrap;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return NormalOverflowWrap;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextDirection e)
-    : CSSValue(PrimitiveClass)
+    : 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) {
     case CSSValueLtr:
         return LTR;
     case CSSValueRtl:
         return RTL;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return LTR;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(WritingMode e)
-    : CSSValue(PrimitiveClass)
+    : 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:
@@ skipping 19 matching lines @@
         return BottomToTopWritingMode;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return TopToBottomWritingMode;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextCombine e)
-    : CSSValue(PrimitiveClass)
+    : 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) {
     case CSSValueNone:
         return TextCombineNone;
     case CSSValueHorizontal:
         return TextCombineHorizontal;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return TextCombineNone;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(RubyPosition position)
-    : CSSValue(PrimitiveClass)
+    : 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) {
     case CSSValueBefore:
         return RubyPositionBefore;
     case CSSValueAfter:
         return RubyPositionAfter;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return RubyPositionBefore;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextEmphasisPosition position)
-    : CSSValue(PrimitiveClass)
+    : 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) {
     case CSSValueOver:
         return TextEmphasisPositionOver;
     case CSSValueUnder:
         return TextEmphasisPositionUnder;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return TextEmphasisPositionOver;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextOverflow overflow)
-    : CSSValue(PrimitiveClass)
+    : 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) {
     case CSSValueClip:
         return TextOverflowClip;
     case CSSValueEllipsis:
         return TextOverflowEllipsis;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return TextOverflowClip;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextEmphasisFill fill)
-    : CSSValue(PrimitiveClass)
+    : 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) {
     case CSSValueFilled:
         return TextEmphasisFillFilled;
     case CSSValueOpen:
         return TextEmphasisFillOpen;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return TextEmphasisFillFilled;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextEmphasisMark mark)
-    : CSSValue(PrimitiveClass)
+    : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (mark) {
     case TextEmphasisMarkDot:
         m_value.valueID = CSSValueDot;
         break;
     case TextEmphasisMarkCircle:
         m_value.valueID = CSSValueCircle;
         break;
     case TextEmphasisMarkDoubleCircle:
@@ skipping 32 matching lines @@
         return TextEmphasisMarkSesame;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return TextEmphasisMarkNone;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextOrientation e)
-    : CSSValue(PrimitiveClass)
+    : 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:
@@ skipping 19 matching lines @@
         return TextOrientationUpright;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return TextOrientationVerticalRight;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EPointerEvents e)
-    : CSSValue(PrimitiveClass)
+    : 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;
     case PE_FILL:
@@ skipping 54 matching lines @@
         return PE_BOUNDINGBOX;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return PE_ALL;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontDescription::Kerning kerning)
-    : CSSValue(PrimitiveClass)
+    : 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:
@@ skipping 17 matching lines @@
         return FontDescription::NoneKerning;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return FontDescription::AutoKerning;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ObjectFit fit)
-    : CSSValue(PrimitiveClass)
+    : 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:
@@ skipping 21 matching lines @@
         return ObjectFitNone;
     case CSSValueScaleDown:
         return ObjectFitScaleDown;
     default:
         ASSERT_NOT_REACHED();
         return ObjectFitFill;
     }
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFillSizeType fillSize)
-    : CSSValue(PrimitiveClass)
+    : 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)
-    : CSSValue(PrimitiveClass)
+    : 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:
@@ skipping 22 matching lines @@
         return SubpixelAntialiased;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return AutoSmoothing;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontWeight weight)
-    : CSSValue(PrimitiveClass)
+    : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (weight) {
     case FontWeight900:
         m_value.valueID = CSSValue900;
         return;
     case FontWeight800:
         m_value.valueID = CSSValue800;
         return;
     case FontWeight700:
@@ skipping 51 matching lines @@
         return FontWeight100;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return FontWeightNormal;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontStyle italic)
-    : CSSValue(PrimitiveClass)
+    : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (italic) {
     case FontStyleNormal:
         m_value.valueID = CSSValueNormal;
         return;
     case FontStyleItalic:
         m_value.valueID = CSSValueItalic;
         return;
     }
@@ skipping 13 matching lines @@
     case CSSValueNormal:
         return FontStyleNormal;
     default:
         break;
     }
     ASSERT_NOT_REACHED();
     return FontStyleNormal;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontStretch stretch)
-    : CSSValue(PrimitiveClass)
+    : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (stretch) {
     case FontStretchUltraCondensed:
         m_value.valueID = CSSValueUltraCondensed;
         return;
     case FontStretchExtraCondensed:
         m_value.valueID = CSSValueExtraCondensed;
         return;
     case FontStretchCondensed:
@@ skipping 47 matching lines @@
         return FontStretchUltraExpanded;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return FontStretchNormal;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontVariant smallCaps)
-    : CSSValue(PrimitiveClass)
+    : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (smallCaps) {
     case FontVariantNormal:
         m_value.valueID = CSSValueNormal;
         return;
     case FontVariantSmallCaps:
         m_value.valueID = CSSValueSmallCaps;
         return;
     }
@@ skipping 11 matching lines @@
     case CSSValueNormal:
         return FontVariantNormal;
     default:
         break;
     }
     ASSERT_NOT_REACHED();
     return FontVariantNormal;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextRenderingMode e)
-    : CSSValue(PrimitiveClass)
+    : 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:
@@ skipping 19 matching lines @@
         return GeometricPrecision;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return AutoTextRendering;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ESpeak e)
-    : CSSValue(PrimitiveClass)
+    : 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:
@@ skipping 21 matching lines @@
         return VisualOrder;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return LogicalOrder;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(Order e)
-    : CSSValue(PrimitiveClass)
+    : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
     case LogicalOrder:
         m_value.valueID = CSSValueLogical;
         break;
     case VisualOrder:
         m_value.valueID = CSSValueVisual;
         break;
     }
@@ skipping 17 matching lines @@
         return SpeakNoPunctuation;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return SpeakNormal;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(WebBlendMode blendMode)
-    : CSSValue(PrimitiveClass)
+    : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (blendMode) {
     case WebBlendModeNormal:
         m_value.valueID = CSSValueNormal;
         break;
     case WebBlendModeMultiply:
         m_value.valueID = CSSValueMultiply;
         break;
     case WebBlendModeScreen:
@@ skipping 79 matching lines @@
         return WebBlendModeLuminosity;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return WebBlendModeNormal;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineCap e)
-    : CSSValue(PrimitiveClass)
+    : 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:
@@ skipping 14 matching lines @@
         return SquareCap;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return ButtCap;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineJoin e)
-    : CSSValue(PrimitiveClass)
+    : 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:
@@ skipping 14 matching lines @@
         return BevelJoin;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return MiterJoin;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(WindRule e)
-    : CSSValue(PrimitiveClass)
+    : 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;
     }
@@ skipping 10 matching lines @@
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return RULE_NONZERO;
 }
 
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EAlignmentBaseline e)
-    : CSSValue(PrimitiveClass)
+    : 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;
     case AB_BEFORE_EDGE:
@@ skipping 59 matching lines @@
         return AB_MATHEMATICAL;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return AB_AUTO;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBorderCollapse e)
-    : CSSValue(PrimitiveClass)
+    : 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) {
     case CSSValueSeparate:
         return BSEPARATE;
     case CSSValueCollapse:
         return BCOLLAPSE;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return BSEPARATE;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EImageRendering e)
-    : CSSValue(PrimitiveClass)
+    : 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:
@@ skipping 24 matching lines @@
         return ImageRenderingOptimizeContrast;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return ImageRenderingAuto;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETransformStyle3D e)
-    : CSSValue(PrimitiveClass)
+    : 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) {
     case CSSValueFlat:
         return TransformStyle3DFlat;
     case CSSValuePreserve3d:
         return TransformStyle3DPreserve3D;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return TransformStyle3DFlat;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBufferedRendering e)
-    : CSSValue(PrimitiveClass)
+    : 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:
@@ skipping 14 matching lines @@
         return BR_STATIC;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return BR_AUTO;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EColorInterpolation e)
-    : CSSValue(PrimitiveClass)
+    : 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:
@@ skipping 14 matching lines @@
         return CI_AUTO;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return CI_AUTO;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EColorRendering e)
-    : CSSValue(PrimitiveClass)
+    : 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:
@@ skipping 14 matching lines @@
         return CR_AUTO;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return CR_AUTO;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EDominantBaseline e)
-    : CSSValue(PrimitiveClass)
+    : 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;
     case DB_NO_CHANGE:
@@ skipping 59 matching lines @@
         return DB_TEXT_BEFORE_EDGE;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return DB_AUTO;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EShapeRendering e)
-    : CSSValue(PrimitiveClass)
+    : 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:
@@ skipping 19 matching lines @@
         return SR_GEOMETRICPRECISION;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return SR_AUTO;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETextAnchor e)
-    : CSSValue(PrimitiveClass)
+    : 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:
@@ skipping 14 matching lines @@
         return TA_END;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return TA_START;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(SVGWritingMode e)
-    : CSSValue(PrimitiveClass)
+    : 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:
@@ skipping 29 matching lines @@
         return WM_TB;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return WM_LRTB;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EVectorEffect e)
-    : CSSValue(PrimitiveClass)
+    : 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) {
     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)
-    : CSSValue(PrimitiveClass)
+    : 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:
@@ skipping 18 matching lines @@
         return PT_MARKERS;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return PT_NONE;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EMaskType e)
-    : CSSValue(PrimitiveClass)
+    : 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;
     }
@@ skipping 39 matching lines @@
         return TouchActionPanX | TouchActionPanY | TouchActionPinchZoom;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return TouchActionNone;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EIsolation i)
-    : CSSValue(PrimitiveClass)
+    : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (i) {
     case IsolationAuto:
         m_value.valueID = CSSValueAuto;
         break;
     case IsolationIsolate:
         m_value.valueID = CSSValueIsolate;
         break;
     }
@@ skipping 28 matching lines @@
         return WebScrollBlocksOnScrollEvent;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
     return WebScrollBlocksOnNone;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(CSSBoxType cssBox)
-    : CSSValue(PrimitiveClass)
+    : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (cssBox) {
     case MarginBox:
         m_value.valueID = CSSValueMarginBox;
         break;
     case BorderBox:
         m_value.valueID = CSSValueBorderBox;
         break;
     case PaddingBox:
@@ skipping 20 matching lines @@
     case CSSValueContentBox:
         return ContentBox;
     default:
         break;
     }
     ASSERT_NOT_REACHED();
     return ContentBox;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ItemPosition itemPosition)
-    : CSSValue(PrimitiveClass)
+    : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (itemPosition) {
     case ItemPositionAuto:
         m_value.valueID = CSSValueAuto;
         break;
     case ItemPositionStretch:
         m_value.valueID = CSSValueStretch;
         break;
     case ItemPositionBaseline:
@@ skipping 62 matching lines @@
     case CSSValueRight:
         return ItemPositionRight;
     default:
         break;
     }
     ASSERT_NOT_REACHED();
     return ItemPositionAuto;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ContentPosition contentPosition)
-    : CSSValue(PrimitiveClass)
+    : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (contentPosition) {
     case ContentPositionAuto:
         m_value.valueID = CSSValueAuto;
         break;
     case ContentPositionBaseline:
         m_value.valueID = CSSValueBaseline;
         break;
     case ContentPositionLastBaseline:
@@ skipping 47 matching lines @@
     case CSSValueRight:
         return ContentPositionRight;
     default:
         break;
     }
     ASSERT_NOT_REACHED();
     return ContentPositionAuto;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ContentDistributionType contentDistribution)
-    : CSSValue(PrimitiveClass)
+    : 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:
@@ skipping 20 matching lines @@
     case CSSValueStretch:
         return ContentDistributionStretch;
     default:
         break;
     }
     ASSERT_NOT_REACHED();
     return ContentDistributionStretch;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(OverflowAlignment overflowAlignment)
-    : CSSValue(PrimitiveClass)
+    : 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:
@@ skipping 10 matching lines @@
     case CSSValueSafe:
         return OverflowAlignmentSafe;
     default:
         break;
     }
     ASSERT_NOT_REACHED();
     return OverflowAlignmentTrue;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ScrollBehavior behavior)
-    : CSSValue(PrimitiveClass)
+    : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (behavior) {
     case ScrollBehaviorAuto:
         m_value.valueID = CSSValueAuto;
         break;
     case ScrollBehaviorSmooth:
         m_value.valueID = CSSValueSmooth;
         break;
     case ScrollBehaviorInstant:
@@ skipping 13 matching lines @@
     default:
         break;
     }
     ASSERT_NOT_REACHED();
     return ScrollBehaviorAuto;
 }
 
 } // namespace blink
 
 #endif