Split CSSPrimitiveValue into CSSPrimitiveValue and CSSIdentifierValue

third_party/WebKit/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 14 matching lines @@
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef CSSPrimitiveValueMappings_h
 #define CSSPrimitiveValueMappings_h
 
 #include "core/CSSValueKeywords.h"
 #include "core/css/CSSCalculationValue.h"
+#include "core/css/CSSIdentifierValue.h"
 #include "core/css/CSSPrimitiveValue.h"
 #include "core/css/CSSReflectionDirection.h"
 #include "core/css/CSSToLengthConversionData.h"
 #include "core/style/ComputedStyleConstants.h"
+#include "core/style/LineClampValue.h"
 #include "core/style/SVGComputedStyleDefs.h"
-#include "core/style/LineClampValue.h"
 #include "platform/Length.h"
 #include "platform/ThemeTypes.h"
 #include "platform/fonts/FontDescription.h"
 #include "platform/fonts/FontSmoothingMode.h"
 #include "platform/fonts/TextRenderingMode.h"
 #include "platform/graphics/GraphicsTypes.h"
 #include "platform/scroll/ScrollableArea.h"
 #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 "wtf/MathExtras.h"
 
 namespace blink {
 
+// TODO(sashab): Move these to CSSPrimitiveValue.h.
 template <>
 inline short CSSPrimitiveValue::convertTo() const {
   ASSERT(isNumber());
   return clampTo<short>(getDoubleValue());
 }
 
 template <>
 inline unsigned short CSSPrimitiveValue::convertTo() const {
   ASSERT(isNumber());
   return clampTo<unsigned short>(getDoubleValue());
@@ skipping 29 matching lines @@
   if (type() == UnitType::Integer)
     return LineClampValue(clampTo<int>(m_value.num), LineClampLineCount);
 
   if (type() == UnitType::Percentage)
     return LineClampValue(clampTo<int>(m_value.num), LineClampPercentage);
 
   ASSERT_NOT_REACHED();
   return LineClampValue();
 }
 
+// TODO(sashab): Move these to CSSIdentifierValueMappings.h, and update to use
+// the CSSValuePool.
 template <>
-inline CSSPrimitiveValue::CSSPrimitiveValue(CSSReflectionDirection e)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(CSSReflectionDirection e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     case ReflectionAbove:
-      m_value.valueID = CSSValueAbove;
+      m_valueID = CSSValueAbove;
       break;
     case ReflectionBelow:
-      m_value.valueID = CSSValueBelow;
+      m_valueID = CSSValueBelow;
       break;
     case ReflectionLeft:
-      m_value.valueID = CSSValueLeft;
+      m_valueID = CSSValueLeft;
       break;
     case ReflectionRight:
-      m_value.valueID = CSSValueRight;
+      m_valueID = CSSValueRight;
   }
 }
 
 template <>
-inline CSSReflectionDirection CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline CSSReflectionDirection CSSIdentifierValue::convertTo() const {
+  switch (m_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)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(ColumnFill columnFill)
+    : CSSValue(IdentifierClass) {
   switch (columnFill) {
     case ColumnFillAuto:
-      m_value.valueID = CSSValueAuto;
+      m_valueID = CSSValueAuto;
       break;
     case ColumnFillBalance:
-      m_value.valueID = CSSValueBalance;
+      m_valueID = CSSValueBalance;
       break;
   }
 }
 
 template <>
-inline ColumnFill CSSPrimitiveValue::convertTo() const {
-  if (type() == UnitType::ValueID) {
-    if (m_value.valueID == CSSValueBalance)
-      return ColumnFillBalance;
-    if (m_value.valueID == CSSValueAuto)
-      return ColumnFillAuto;
-  }
+inline ColumnFill CSSIdentifierValue::convertTo() const {
+  if (m_valueID == CSSValueBalance)
+    return ColumnFillBalance;
+  if (m_valueID == CSSValueAuto)
+    return ColumnFillAuto;
   ASSERT_NOT_REACHED();
   return ColumnFillBalance;
 }
 
 template <>
-inline CSSPrimitiveValue::CSSPrimitiveValue(ColumnSpan columnSpan)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(ColumnSpan columnSpan)
+    : CSSValue(IdentifierClass) {
   switch (columnSpan) {
     case ColumnSpanAll:
-      m_value.valueID = CSSValueAll;
+      m_valueID = CSSValueAll;
       break;
     case ColumnSpanNone:
-      m_value.valueID = CSSValueNone;
+      m_valueID = CSSValueNone;
       break;
   }
 }
 
 template <>
-inline ColumnSpan CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline ColumnSpan CSSIdentifierValue::convertTo() const {
+  switch (m_valueID) {
     case CSSValueAll:
       return ColumnSpanAll;
     default:
       ASSERT_NOT_REACHED();
     // fall-through
     case CSSValueNone:
       return ColumnSpanNone;
   }
 }
 
 template <>
-inline CSSPrimitiveValue::CSSPrimitiveValue(PrintColorAdjust value)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(PrintColorAdjust value)
+    : CSSValue(IdentifierClass) {
   switch (value) {
     case PrintColorAdjustExact:
-      m_value.valueID = CSSValueExact;
+      m_valueID = CSSValueExact;
       break;
     case PrintColorAdjustEconomy:
-      m_value.valueID = CSSValueEconomy;
+      m_valueID = CSSValueEconomy;
       break;
   }
 }
 
 template <>
-inline PrintColorAdjust CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline PrintColorAdjust CSSIdentifierValue::convertTo() const {
+  switch (m_valueID) {
     case CSSValueEconomy:
       return PrintColorAdjustEconomy;
     case CSSValueExact:
       return PrintColorAdjustExact;
     default:
       break;
   }
 
   ASSERT_NOT_REACHED();
   return PrintColorAdjustEconomy;
 }
 
 template <>
-inline CSSPrimitiveValue::CSSPrimitiveValue(EBorderStyle e)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(EBorderStyle e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     case BorderStyleNone:
-      m_value.valueID = CSSValueNone;
+      m_valueID = CSSValueNone;
       break;
     case BorderStyleHidden:
-      m_value.valueID = CSSValueHidden;
+      m_valueID = CSSValueHidden;
       break;
     case BorderStyleInset:
-      m_value.valueID = CSSValueInset;
+      m_valueID = CSSValueInset;
       break;
     case BorderStyleGroove:
-      m_value.valueID = CSSValueGroove;
+      m_valueID = CSSValueGroove;
       break;
     case BorderStyleRidge:
-      m_value.valueID = CSSValueRidge;
+      m_valueID = CSSValueRidge;
       break;
     case BorderStyleOutset:
-      m_value.valueID = CSSValueOutset;
+      m_valueID = CSSValueOutset;
       break;
     case BorderStyleDotted:
-      m_value.valueID = CSSValueDotted;
+      m_valueID = CSSValueDotted;
       break;
     case BorderStyleDashed:
-      m_value.valueID = CSSValueDashed;
+      m_valueID = CSSValueDashed;
       break;
     case BorderStyleSolid:
-      m_value.valueID = CSSValueSolid;
+      m_valueID = CSSValueSolid;
       break;
     case BorderStyleDouble:
-      m_value.valueID = CSSValueDouble;
+      m_valueID = CSSValueDouble;
       break;
   }
 }
 
 template <>
-inline EBorderStyle CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  if (m_value.valueID == CSSValueAuto)  // Valid for CSS outline-style
+inline EBorderStyle CSSIdentifierValue::convertTo() const {
+  if (m_valueID == CSSValueAuto)  // Valid for CSS outline-style
     return BorderStyleDotted;
-  return (EBorderStyle)(m_value.valueID - CSSValueNone);
+  return (EBorderStyle)(m_valueID - CSSValueNone);
 }
 
 template <>
-inline OutlineIsAuto CSSPrimitiveValue::convertTo() const {
-  if (m_value.valueID == CSSValueAuto)
+inline OutlineIsAuto CSSIdentifierValue::convertTo() const {
+  if (m_valueID == CSSValueAuto)
     return OutlineIsAutoOn;
   return OutlineIsAutoOff;
 }
 
 template <>
-inline CSSPrimitiveValue::CSSPrimitiveValue(CompositeOperator e)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(CompositeOperator e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     case CompositeClear:
-      m_value.valueID = CSSValueClear;
+      m_valueID = CSSValueClear;
       break;
     case CompositeCopy:
-      m_value.valueID = CSSValueCopy;
+      m_valueID = CSSValueCopy;
       break;
     case CompositeSourceOver:
-      m_value.valueID = CSSValueSourceOver;
+      m_valueID = CSSValueSourceOver;
       break;
     case CompositeSourceIn:
-      m_value.valueID = CSSValueSourceIn;
+      m_valueID = CSSValueSourceIn;
       break;
     case CompositeSourceOut:
-      m_value.valueID = CSSValueSourceOut;
+      m_valueID = CSSValueSourceOut;
       break;
     case CompositeSourceAtop:
-      m_value.valueID = CSSValueSourceAtop;
+      m_valueID = CSSValueSourceAtop;
       break;
     case CompositeDestinationOver:
-      m_value.valueID = CSSValueDestinationOver;
+      m_valueID = CSSValueDestinationOver;
       break;
     case CompositeDestinationIn:
-      m_value.valueID = CSSValueDestinationIn;
+      m_valueID = CSSValueDestinationIn;
       break;
     case CompositeDestinationOut:
-      m_value.valueID = CSSValueDestinationOut;
+      m_valueID = CSSValueDestinationOut;
       break;
     case CompositeDestinationAtop:
-      m_value.valueID = CSSValueDestinationAtop;
+      m_valueID = CSSValueDestinationAtop;
       break;
     case CompositeXOR:
-      m_value.valueID = CSSValueXor;
+      m_valueID = CSSValueXor;
       break;
     case CompositePlusLighter:
-      m_value.valueID = CSSValuePlusLighter;
+      m_valueID = CSSValuePlusLighter;
       break;
     default:
       ASSERT_NOT_REACHED();
       break;
   }
 }
 
 template <>
-inline CompositeOperator CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline CompositeOperator CSSIdentifierValue::convertTo() const {
+  switch (m_valueID) {
     case CSSValueClear:
       return CompositeClear;
     case CSSValueCopy:
       return CompositeCopy;
     case CSSValueSourceOver:
       return CompositeSourceOver;
     case CSSValueSourceIn:
       return CompositeSourceIn;
     case CSSValueSourceOut:
       return CompositeSourceOut;
@@ skipping 13 matching lines @@
       return CompositePlusLighter;
     default:
       break;
   }
 
   ASSERT_NOT_REACHED();
   return CompositeClear;
 }
 
 template <>
-inline CSSPrimitiveValue::CSSPrimitiveValue(ControlPart e)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(ControlPart e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     case NoControlPart:
-      m_value.valueID = CSSValueNone;
+      m_valueID = CSSValueNone;
       break;
     case CheckboxPart:
-      m_value.valueID = CSSValueCheckbox;
+      m_valueID = CSSValueCheckbox;
       break;
     case RadioPart:
-      m_value.valueID = CSSValueRadio;
+      m_valueID = CSSValueRadio;
       break;
     case PushButtonPart:
-      m_value.valueID = CSSValuePushButton;
+      m_valueID = CSSValuePushButton;
       break;
     case SquareButtonPart:
-      m_value.valueID = CSSValueSquareButton;
+      m_valueID = CSSValueSquareButton;
       break;
     case ButtonPart:
-      m_value.valueID = CSSValueButton;
+      m_valueID = CSSValueButton;
       break;
     case ButtonBevelPart:
-      m_value.valueID = CSSValueButtonBevel;
+      m_valueID = CSSValueButtonBevel;
       break;
     case InnerSpinButtonPart:
-      m_value.valueID = CSSValueInnerSpinButton;
+      m_valueID = CSSValueInnerSpinButton;
       break;
     case ListboxPart:
-      m_value.valueID = CSSValueListbox;
+      m_valueID = CSSValueListbox;
       break;
     case ListItemPart:
-      m_value.valueID = CSSValueListitem;
+      m_valueID = CSSValueListitem;
       break;
     case MediaEnterFullscreenButtonPart:
-      m_value.valueID = CSSValueMediaEnterFullscreenButton;
+      m_valueID = CSSValueMediaEnterFullscreenButton;
       break;
     case MediaExitFullscreenButtonPart:
-      m_value.valueID = CSSValueMediaExitFullscreenButton;
+      m_valueID = CSSValueMediaExitFullscreenButton;
       break;
     case MediaPlayButtonPart:
-      m_value.valueID = CSSValueMediaPlayButton;
+      m_valueID = CSSValueMediaPlayButton;
       break;
     case MediaOverlayPlayButtonPart:
-      m_value.valueID = CSSValueMediaOverlayPlayButton;
+      m_valueID = CSSValueMediaOverlayPlayButton;
       break;
     case MediaMuteButtonPart:
-      m_value.valueID = CSSValueMediaMuteButton;
+      m_valueID = CSSValueMediaMuteButton;
       break;
     case MediaToggleClosedCaptionsButtonPart:
-      m_value.valueID = CSSValueMediaToggleClosedCaptionsButton;
+      m_valueID = CSSValueMediaToggleClosedCaptionsButton;
       break;
     case MediaCastOffButtonPart:
-      m_value.valueID = CSSValueInternalMediaCastOffButton;
+      m_valueID = CSSValueInternalMediaCastOffButton;
       break;
     case MediaOverlayCastOffButtonPart:
-      m_value.valueID = CSSValueInternalMediaOverlayCastOffButton;
+      m_valueID = CSSValueInternalMediaOverlayCastOffButton;
       break;
     case MediaSliderPart:
-      m_value.valueID = CSSValueMediaSlider;
+      m_valueID = CSSValueMediaSlider;
       break;
     case MediaSliderThumbPart:
-      m_value.valueID = CSSValueMediaSliderthumb;
+      m_valueID = CSSValueMediaSliderthumb;
       break;
     case MediaVolumeSliderContainerPart:
-      m_value.valueID = CSSValueMediaVolumeSliderContainer;
+      m_valueID = CSSValueMediaVolumeSliderContainer;
       break;
     case MediaVolumeSliderPart:
-      m_value.valueID = CSSValueMediaVolumeSlider;
+      m_valueID = CSSValueMediaVolumeSlider;
       break;
     case MediaVolumeSliderThumbPart:
-      m_value.valueID = CSSValueMediaVolumeSliderthumb;
+      m_valueID = CSSValueMediaVolumeSliderthumb;
       break;
     case MediaControlsBackgroundPart:
-      m_value.valueID = CSSValueMediaControlsBackground;
+      m_valueID = CSSValueMediaControlsBackground;
       break;
     case MediaControlsFullscreenBackgroundPart:
-      m_value.valueID = CSSValueMediaControlsFullscreenBackground;
+      m_valueID = CSSValueMediaControlsFullscreenBackground;
       break;
     case MediaFullscreenVolumeSliderPart:
-      m_value.valueID = CSSValueMediaFullscreenVolumeSlider;
+      m_valueID = CSSValueMediaFullscreenVolumeSlider;
       break;
     case MediaFullscreenVolumeSliderThumbPart:
-      m_value.valueID = CSSValueMediaFullscreenVolumeSliderThumb;
+      m_valueID = CSSValueMediaFullscreenVolumeSliderThumb;
       break;
     case MediaCurrentTimePart:
-      m_value.valueID = CSSValueMediaCurrentTimeDisplay;
+      m_valueID = CSSValueMediaCurrentTimeDisplay;
       break;
     case MediaTimeRemainingPart:
-      m_value.valueID = CSSValueMediaTimeRemainingDisplay;
+      m_valueID = CSSValueMediaTimeRemainingDisplay;
       break;
     case MediaTrackSelectionCheckmarkPart:
-      m_value.valueID = CSSValueInternalMediaTrackSelectionCheckmark;
+      m_valueID = CSSValueInternalMediaTrackSelectionCheckmark;
       break;
     case MediaClosedCaptionsIconPart:
-      m_value.valueID = CSSValueInternalMediaClosedCaptionsIcon;
+      m_valueID = CSSValueInternalMediaClosedCaptionsIcon;
       break;
     case MediaSubtitlesIconPart:
-      m_value.valueID = CSSValueInternalMediaSubtitlesIcon;
+      m_valueID = CSSValueInternalMediaSubtitlesIcon;
       break;
     case MediaOverflowMenuButtonPart:
-      m_value.valueID = CSSValueInternalMediaOverflowButton;
+      m_valueID = CSSValueInternalMediaOverflowButton;
       break;
     case MediaDownloadIconPart:
-      m_value.valueID = CSSValueInternalMediaDownloadButton;
+      m_valueID = CSSValueInternalMediaDownloadButton;
       break;
     case MenulistPart:
-      m_value.valueID = CSSValueMenulist;
+      m_valueID = CSSValueMenulist;
       break;
     case MenulistButtonPart:
-      m_value.valueID = CSSValueMenulistButton;
+      m_valueID = CSSValueMenulistButton;
       break;
     case MenulistTextPart:
-      m_value.valueID = CSSValueMenulistText;
+      m_valueID = CSSValueMenulistText;
       break;
     case MenulistTextFieldPart:
-      m_value.valueID = CSSValueMenulistTextfield;
+      m_valueID = CSSValueMenulistTextfield;
       break;
     case MeterPart:
-      m_value.valueID = CSSValueMeter;
+      m_valueID = CSSValueMeter;
       break;
     case ProgressBarPart:
-      m_value.valueID = CSSValueProgressBar;
+      m_valueID = CSSValueProgressBar;
       break;
     case ProgressBarValuePart:
-      m_value.valueID = CSSValueProgressBarValue;
+      m_valueID = CSSValueProgressBarValue;
       break;
     case SliderHorizontalPart:
-      m_value.valueID = CSSValueSliderHorizontal;
+      m_valueID = CSSValueSliderHorizontal;
       break;
     case SliderVerticalPart:
-      m_value.valueID = CSSValueSliderVertical;
+      m_valueID = CSSValueSliderVertical;
       break;
     case SliderThumbHorizontalPart:
-      m_value.valueID = CSSValueSliderthumbHorizontal;
+      m_valueID = CSSValueSliderthumbHorizontal;
       break;
     case SliderThumbVerticalPart:
-      m_value.valueID = CSSValueSliderthumbVertical;
+      m_valueID = CSSValueSliderthumbVertical;
       break;
     case CaretPart:
-      m_value.valueID = CSSValueCaret;
+      m_valueID = CSSValueCaret;
       break;
     case SearchFieldPart:
-      m_value.valueID = CSSValueSearchfield;
+      m_valueID = CSSValueSearchfield;
       break;
     case SearchFieldCancelButtonPart:
-      m_value.valueID = CSSValueSearchfieldCancelButton;
+      m_valueID = CSSValueSearchfieldCancelButton;
       break;
     case TextFieldPart:
-      m_value.valueID = CSSValueTextfield;
+      m_valueID = CSSValueTextfield;
       break;
     case TextAreaPart:
-      m_value.valueID = CSSValueTextarea;
+      m_valueID = CSSValueTextarea;
       break;
     case CapsLockIndicatorPart:
-      m_value.valueID = CSSValueCapsLockIndicator;
+      m_valueID = CSSValueCapsLockIndicator;
       break;
   }
 }
 
 template <>
-inline ControlPart CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  if (m_value.valueID == CSSValueNone)
+inline ControlPart CSSIdentifierValue::convertTo() const {
+  if (m_valueID == CSSValueNone)
     return NoControlPart;
-  return ControlPart(m_value.valueID - CSSValueCheckbox + 1);
+  return ControlPart(m_valueID - CSSValueCheckbox + 1);
 }
 
 template <>
-inline CSSPrimitiveValue::CSSPrimitiveValue(EBackfaceVisibility e)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(EBackfaceVisibility e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     case BackfaceVisibilityVisible:
-      m_value.valueID = CSSValueVisible;
+      m_valueID = CSSValueVisible;
       break;
     case BackfaceVisibilityHidden:
-      m_value.valueID = CSSValueHidden;
+      m_valueID = CSSValueHidden;
       break;
   }
 }
 
 template <>
-inline EBackfaceVisibility CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline EBackfaceVisibility CSSIdentifierValue::convertTo() const {
+  switch (m_valueID) {
     case CSSValueVisible:
       return BackfaceVisibilityVisible;
     case CSSValueHidden:
       return BackfaceVisibilityHidden;
     default:
       break;
   }
 
   ASSERT_NOT_REACHED();
   return BackfaceVisibilityHidden;
 }
 
 template <>
-inline CSSPrimitiveValue::CSSPrimitiveValue(EFillAttachment e)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(EFillAttachment e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     case ScrollBackgroundAttachment:
-      m_value.valueID = CSSValueScroll;
+      m_valueID = CSSValueScroll;
       break;
     case LocalBackgroundAttachment:
-      m_value.valueID = CSSValueLocal;
+      m_valueID = CSSValueLocal;
       break;
     case FixedBackgroundAttachment:
-      m_value.valueID = CSSValueFixed;
+      m_valueID = CSSValueFixed;
       break;
   }
 }
 
 template <>
-inline EFillAttachment CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline EFillAttachment CSSIdentifierValue::convertTo() const {
+  switch (m_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)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(EFillBox e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     case BorderFillBox:
-      m_value.valueID = CSSValueBorderBox;
+      m_valueID = CSSValueBorderBox;
       break;
     case PaddingFillBox:
-      m_value.valueID = CSSValuePaddingBox;
+      m_valueID = CSSValuePaddingBox;
       break;
     case ContentFillBox:
-      m_value.valueID = CSSValueContentBox;
+      m_valueID = CSSValueContentBox;
       break;
     case TextFillBox:
-      m_value.valueID = CSSValueText;
+      m_valueID = CSSValueText;
       break;
   }
 }
 
 template <>
-inline EFillBox CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline EFillBox CSSIdentifierValue::convertTo() const {
+  switch (m_valueID) {
     case CSSValueBorder:
     case CSSValueBorderBox:
       return BorderFillBox;
     case CSSValuePadding:
     case CSSValuePaddingBox:
       return PaddingFillBox;
     case CSSValueContent:
     case CSSValueContentBox:
       return ContentFillBox;
     case CSSValueText:
       return TextFillBox;
     default:
       break;
   }
 
   ASSERT_NOT_REACHED();
   return BorderFillBox;
 }
 
 template <>
-inline CSSPrimitiveValue::CSSPrimitiveValue(EFillRepeat e)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(EFillRepeat e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     case RepeatFill:
-      m_value.valueID = CSSValueRepeat;
+      m_valueID = CSSValueRepeat;
       break;
     case NoRepeatFill:
-      m_value.valueID = CSSValueNoRepeat;
+      m_valueID = CSSValueNoRepeat;
       break;
     case RoundFill:
-      m_value.valueID = CSSValueRound;
+      m_valueID = CSSValueRound;
       break;
     case SpaceFill:
-      m_value.valueID = CSSValueSpace;
+      m_valueID = CSSValueSpace;
       break;
   }
 }
 
 template <>
-inline EFillRepeat CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline EFillRepeat CSSIdentifierValue::convertTo() const {
+  switch (m_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)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(EBoxPack e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     case BoxPackStart:
-      m_value.valueID = CSSValueStart;
+      m_valueID = CSSValueStart;
       break;
     case BoxPackCenter:
-      m_value.valueID = CSSValueCenter;
+      m_valueID = CSSValueCenter;
       break;
     case BoxPackEnd:
-      m_value.valueID = CSSValueEnd;
+      m_valueID = CSSValueEnd;
       break;
     case BoxPackJustify:
-      m_value.valueID = CSSValueJustify;
+      m_valueID = CSSValueJustify;
       break;
   }
 }
 
 template <>
-inline EBoxPack CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline EBoxPack CSSIdentifierValue::convertTo() const {
+  switch (m_valueID) {
     case CSSValueStart:
       return BoxPackStart;
     case CSSValueEnd:
       return BoxPackEnd;
     case CSSValueCenter:
       return BoxPackCenter;
     case CSSValueJustify:
       return BoxPackJustify;
     default:
       break;
   }
 
   ASSERT_NOT_REACHED();
   return BoxPackJustify;
 }
 
 template <>
-inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxAlignment e)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(EBoxAlignment e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     case BSTRETCH:
-      m_value.valueID = CSSValueStretch;
+      m_valueID = CSSValueStretch;
       break;
     case BSTART:
-      m_value.valueID = CSSValueStart;
+      m_valueID = CSSValueStart;
       break;
     case BCENTER:
-      m_value.valueID = CSSValueCenter;
+      m_valueID = CSSValueCenter;
       break;
     case BEND:
-      m_value.valueID = CSSValueEnd;
+      m_valueID = CSSValueEnd;
       break;
     case BBASELINE:
-      m_value.valueID = CSSValueBaseline;
+      m_valueID = CSSValueBaseline;
       break;
   }
 }
 
 template <>
-inline EBoxAlignment CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline EBoxAlignment CSSIdentifierValue::convertTo() const {
+  switch (m_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)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(EBoxDecorationBreak e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     case BoxDecorationBreakSlice:
-      m_value.valueID = CSSValueSlice;
+      m_valueID = CSSValueSlice;
       break;
     case BoxDecorationBreakClone:
-      m_value.valueID = CSSValueClone;
+      m_valueID = CSSValueClone;
       break;
   }
 }
 
 template <>
-inline EBoxDecorationBreak CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline EBoxDecorationBreak CSSIdentifierValue::convertTo() const {
+  switch (m_valueID) {
     case CSSValueSlice:
       return BoxDecorationBreakSlice;
     case CSSValueClone:
       return BoxDecorationBreakClone;
     default:
       break;
   }
 
   ASSERT_NOT_REACHED();
   return BoxDecorationBreakSlice;
 }
 
 template <>
-inline CSSPrimitiveValue::CSSPrimitiveValue(BackgroundEdgeOrigin e)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(BackgroundEdgeOrigin e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     case TopEdge:
-      m_value.valueID = CSSValueTop;
+      m_valueID = CSSValueTop;
       break;
     case RightEdge:
-      m_value.valueID = CSSValueRight;
+      m_valueID = CSSValueRight;
       break;
     case BottomEdge:
-      m_value.valueID = CSSValueBottom;
+      m_valueID = CSSValueBottom;
       break;
     case LeftEdge:
-      m_value.valueID = CSSValueLeft;
+      m_valueID = CSSValueLeft;
       break;
   }
 }
 
 template <>
-inline BackgroundEdgeOrigin CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline BackgroundEdgeOrigin CSSIdentifierValue::convertTo() const {
+  switch (m_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)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(EBoxSizing e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     case BoxSizingBorderBox:
-      m_value.valueID = CSSValueBorderBox;
+      m_valueID = CSSValueBorderBox;
       break;
     case BoxSizingContentBox:
-      m_value.valueID = CSSValueContentBox;
+      m_valueID = CSSValueContentBox;
       break;
   }
 }
 
 template <>
-inline EBoxSizing CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline EBoxSizing CSSIdentifierValue::convertTo() const {
+  switch (m_valueID) {
     case CSSValueBorderBox:
       return BoxSizingBorderBox;
     case CSSValueContentBox:
       return BoxSizingContentBox;
     default:
       break;
   }
 
   ASSERT_NOT_REACHED();
   return BoxSizingBorderBox;
 }
 
 template <>
-inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxDirection e)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(EBoxDirection e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     case BNORMAL:
-      m_value.valueID = CSSValueNormal;
+      m_valueID = CSSValueNormal;
       break;
     case BREVERSE:
-      m_value.valueID = CSSValueReverse;
+      m_valueID = CSSValueReverse;
       break;
   }
 }
 
 template <>
-inline EBoxDirection CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline EBoxDirection CSSIdentifierValue::convertTo() const {
+  switch (m_valueID) {
     case CSSValueNormal:
       return BNORMAL;
     case CSSValueReverse:
       return BREVERSE;
     default:
       break;
   }
 
   ASSERT_NOT_REACHED();
   return BNORMAL;
 }
 
 template <>
-inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxLines e)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(EBoxLines e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     case SINGLE:
-      m_value.valueID = CSSValueSingle;
+      m_valueID = CSSValueSingle;
       break;
     case MULTIPLE:
-      m_value.valueID = CSSValueMultiple;
+      m_valueID = CSSValueMultiple;
       break;
   }
 }
 
 template <>
-inline EBoxLines CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline EBoxLines CSSIdentifierValue::convertTo() const {
+  switch (m_valueID) {
     case CSSValueSingle:
       return SINGLE;
     case CSSValueMultiple:
       return MULTIPLE;
     default:
       break;
   }
 
   ASSERT_NOT_REACHED();
   return SINGLE;
 }
 
 template <>
-inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxOrient e)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(EBoxOrient e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     case HORIZONTAL:
-      m_value.valueID = CSSValueHorizontal;
+      m_valueID = CSSValueHorizontal;
       break;
     case VERTICAL:
-      m_value.valueID = CSSValueVertical;
+      m_valueID = CSSValueVertical;
       break;
   }
 }
 
 template <>
-inline EBoxOrient CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline EBoxOrient CSSIdentifierValue::convertTo() const {
+  switch (m_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)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(ECaptionSide e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     case ECaptionSide::Left:
-      m_value.valueID = CSSValueLeft;
+      m_valueID = CSSValueLeft;
       break;
     case ECaptionSide::Right:
-      m_value.valueID = CSSValueRight;
+      m_valueID = CSSValueRight;
       break;
     case ECaptionSide::Top:
-      m_value.valueID = CSSValueTop;
+      m_valueID = CSSValueTop;
       break;
     case ECaptionSide::Bottom:
-      m_value.valueID = CSSValueBottom;
+      m_valueID = CSSValueBottom;
       break;
   }
 }
 
 template <>
-inline ECaptionSide CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline ECaptionSide CSSIdentifierValue::convertTo() const {
+  switch (m_valueID) {
     case CSSValueLeft:
       return ECaptionSide::Left;
     case CSSValueRight:
       return ECaptionSide::Right;
     case CSSValueTop:
       return ECaptionSide::Top;
     case CSSValueBottom:
       return ECaptionSide::Bottom;
     default:
       break;
   }
 
   ASSERT_NOT_REACHED();
   return ECaptionSide::Top;
 }
 
 template <>
-inline CSSPrimitiveValue::CSSPrimitiveValue(EClear e)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(EClear e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     case ClearNone:
-      m_value.valueID = CSSValueNone;
+      m_valueID = CSSValueNone;
       break;
     case ClearLeft:
-      m_value.valueID = CSSValueLeft;
+      m_valueID = CSSValueLeft;
       break;
     case ClearRight:
-      m_value.valueID = CSSValueRight;
+      m_valueID = CSSValueRight;
       break;
     case ClearBoth:
-      m_value.valueID = CSSValueBoth;
+      m_valueID = CSSValueBoth;
       break;
   }
 }
 
 template <>
-inline EClear CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline EClear CSSIdentifierValue::convertTo() const {
+  switch (m_valueID) {
     case CSSValueNone:
       return ClearNone;
     case CSSValueLeft:
       return ClearLeft;
     case CSSValueRight:
       return ClearRight;
     case CSSValueBoth:
       return ClearBoth;
     default:
       break;
   }
 
   ASSERT_NOT_REACHED();
   return ClearNone;
 }
 
 template <>
-inline CSSPrimitiveValue::CSSPrimitiveValue(ECursor e)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(ECursor e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     case CURSOR_AUTO:
-      m_value.valueID = CSSValueAuto;
+      m_valueID = CSSValueAuto;
       break;
     case CURSOR_CROSS:
-      m_value.valueID = CSSValueCrosshair;
+      m_valueID = CSSValueCrosshair;
       break;
     case CURSOR_DEFAULT:
-      m_value.valueID = CSSValueDefault;
+      m_valueID = CSSValueDefault;
       break;
     case CURSOR_POINTER:
-      m_value.valueID = CSSValuePointer;
+      m_valueID = CSSValuePointer;
       break;
     case CURSOR_MOVE:
-      m_value.valueID = CSSValueMove;
+      m_valueID = CSSValueMove;
       break;
     case CURSOR_CELL:
-      m_value.valueID = CSSValueCell;
+      m_valueID = CSSValueCell;
       break;
     case CURSOR_VERTICAL_TEXT:
-      m_value.valueID = CSSValueVerticalText;
+      m_valueID = CSSValueVerticalText;
       break;
     case CURSOR_CONTEXT_MENU:
-      m_value.valueID = CSSValueContextMenu;
+      m_valueID = CSSValueContextMenu;
       break;
     case CURSOR_ALIAS:
-      m_value.valueID = CSSValueAlias;
+      m_valueID = CSSValueAlias;
       break;
     case CURSOR_COPY:
-      m_value.valueID = CSSValueCopy;
+      m_valueID = CSSValueCopy;
       break;
     case CURSOR_NONE:
-      m_value.valueID = CSSValueNone;
+      m_valueID = CSSValueNone;
       break;
     case CURSOR_PROGRESS:
-      m_value.valueID = CSSValueProgress;
+      m_valueID = CSSValueProgress;
       break;
     case CURSOR_NO_DROP:
-      m_value.valueID = CSSValueNoDrop;
+      m_valueID = CSSValueNoDrop;
       break;
     case CURSOR_NOT_ALLOWED:
-      m_value.valueID = CSSValueNotAllowed;
+      m_valueID = CSSValueNotAllowed;
       break;
     case CURSOR_ZOOM_IN:
-      m_value.valueID = CSSValueZoomIn;
+      m_valueID = CSSValueZoomIn;
       break;
     case CURSOR_ZOOM_OUT:
-      m_value.valueID = CSSValueZoomOut;
+      m_valueID = CSSValueZoomOut;
       break;
     case CURSOR_E_RESIZE:
-      m_value.valueID = CSSValueEResize;
+      m_valueID = CSSValueEResize;
       break;
     case CURSOR_NE_RESIZE:
-      m_value.valueID = CSSValueNeResize;
+      m_valueID = CSSValueNeResize;
       break;
     case CURSOR_NW_RESIZE:
-      m_value.valueID = CSSValueNwResize;
+      m_valueID = CSSValueNwResize;
       break;
     case CURSOR_N_RESIZE:
-      m_value.valueID = CSSValueNResize;
+      m_valueID = CSSValueNResize;
       break;
     case CURSOR_SE_RESIZE:
-      m_value.valueID = CSSValueSeResize;
+      m_valueID = CSSValueSeResize;
       break;
     case CURSOR_SW_RESIZE:
-      m_value.valueID = CSSValueSwResize;
+      m_valueID = CSSValueSwResize;
       break;
     case CURSOR_S_RESIZE:
-      m_value.valueID = CSSValueSResize;
+      m_valueID = CSSValueSResize;
       break;
     case CURSOR_W_RESIZE:
-      m_value.valueID = CSSValueWResize;
+      m_valueID = CSSValueWResize;
       break;
     case CURSOR_EW_RESIZE:
-      m_value.valueID = CSSValueEwResize;
+      m_valueID = CSSValueEwResize;
       break;
     case CURSOR_NS_RESIZE:
-      m_value.valueID = CSSValueNsResize;
+      m_valueID = CSSValueNsResize;
       break;
     case CURSOR_NESW_RESIZE:
-      m_value.valueID = CSSValueNeswResize;
+      m_valueID = CSSValueNeswResize;
       break;
     case CURSOR_NWSE_RESIZE:
-      m_value.valueID = CSSValueNwseResize;
+      m_valueID = CSSValueNwseResize;
       break;
     case CURSOR_COL_RESIZE:
-      m_value.valueID = CSSValueColResize;
+      m_valueID = CSSValueColResize;
       break;
     case CURSOR_ROW_RESIZE:
-      m_value.valueID = CSSValueRowResize;
+      m_valueID = CSSValueRowResize;
       break;
     case CURSOR_TEXT:
-      m_value.valueID = CSSValueText;
+      m_valueID = CSSValueText;
       break;
     case CURSOR_WAIT:
-      m_value.valueID = CSSValueWait;
+      m_valueID = CSSValueWait;
       break;
     case CURSOR_HELP:
-      m_value.valueID = CSSValueHelp;
+      m_valueID = CSSValueHelp;
       break;
     case CURSOR_ALL_SCROLL:
-      m_value.valueID = CSSValueAllScroll;
+      m_valueID = CSSValueAllScroll;
       break;
     case CURSOR_WEBKIT_GRAB:
-      m_value.valueID = CSSValueWebkitGrab;
+      m_valueID = CSSValueWebkitGrab;
       break;
     case CURSOR_WEBKIT_GRABBING:
-      m_value.valueID = CSSValueWebkitGrabbing;
+      m_valueID = CSSValueWebkitGrabbing;
       break;
   }
 }
 
 template <>
-inline ECursor CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline ECursor CSSIdentifierValue::convertTo() const {
+  switch (m_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>(m_valueID - CSSValueAuto);
   }
 }
 
 template <>
-inline CSSPrimitiveValue::CSSPrimitiveValue(EDisplay e)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(EDisplay e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     case EDisplay::Inline:
-      m_value.valueID = CSSValueInline;
+      m_valueID = CSSValueInline;
       break;
     case EDisplay::Block:
-      m_value.valueID = CSSValueBlock;
+      m_valueID = CSSValueBlock;
       break;
     case EDisplay::ListItem:
-      m_value.valueID = CSSValueListItem;
+      m_valueID = CSSValueListItem;
       break;
     case EDisplay::InlineBlock:
-      m_value.valueID = CSSValueInlineBlock;
+      m_valueID = CSSValueInlineBlock;
       break;
     case EDisplay::Table:
-      m_value.valueID = CSSValueTable;
+      m_valueID = CSSValueTable;
       break;
     case EDisplay::InlineTable:
-      m_value.valueID = CSSValueInlineTable;
+      m_valueID = CSSValueInlineTable;
       break;
     case EDisplay::TableRowGroup:
-      m_value.valueID = CSSValueTableRowGroup;
+      m_valueID = CSSValueTableRowGroup;
       break;
     case EDisplay::TableHeaderGroup:
-      m_value.valueID = CSSValueTableHeaderGroup;
+      m_valueID = CSSValueTableHeaderGroup;
       break;
     case EDisplay::TableFooterGroup:
-      m_value.valueID = CSSValueTableFooterGroup;
+      m_valueID = CSSValueTableFooterGroup;
       break;
     case EDisplay::TableRow:
-      m_value.valueID = CSSValueTableRow;
+      m_valueID = CSSValueTableRow;
       break;
     case EDisplay::TableColumnGroup:
-      m_value.valueID = CSSValueTableColumnGroup;
+      m_valueID = CSSValueTableColumnGroup;
       break;
     case EDisplay::TableColumn:
-      m_value.valueID = CSSValueTableColumn;
+      m_valueID = CSSValueTableColumn;
       break;
     case EDisplay::TableCell:
-      m_value.valueID = CSSValueTableCell;
+      m_valueID = CSSValueTableCell;
       break;
     case EDisplay::TableCaption:
-      m_value.valueID = CSSValueTableCaption;
+      m_valueID = CSSValueTableCaption;
       break;
     case EDisplay::Box:
-      m_value.valueID = CSSValueWebkitBox;
+      m_valueID = CSSValueWebkitBox;
       break;
     case EDisplay::InlineBox:
-      m_value.valueID = CSSValueWebkitInlineBox;
+      m_valueID = CSSValueWebkitInlineBox;
       break;
     case EDisplay::Flex:
-      m_value.valueID = CSSValueFlex;
+      m_valueID = CSSValueFlex;
       break;
     case EDisplay::InlineFlex:
-      m_value.valueID = CSSValueInlineFlex;
+      m_valueID = CSSValueInlineFlex;
       break;
     case EDisplay::Grid:
-      m_value.valueID = CSSValueGrid;
+      m_valueID = CSSValueGrid;
       break;
     case EDisplay::InlineGrid:
-      m_value.valueID = CSSValueInlineGrid;
+      m_valueID = CSSValueInlineGrid;
       break;
     case EDisplay::None:
-      m_value.valueID = CSSValueNone;
+      m_valueID = CSSValueNone;
       break;
   }
 }
 
 template <>
-inline EDisplay CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  if (m_value.valueID == CSSValueNone)
+inline EDisplay CSSIdentifierValue::convertTo() const {
+  if (m_valueID == CSSValueNone)
     return EDisplay::None;
 
-  if (m_value.valueID == CSSValueWebkitFlex)
+  if (m_valueID == CSSValueWebkitFlex)
     return EDisplay::Flex;
-  if (m_value.valueID == CSSValueWebkitInlineFlex)
+  if (m_valueID == CSSValueWebkitInlineFlex)
     return EDisplay::InlineFlex;
 
-  EDisplay display = static_cast<EDisplay>(m_value.valueID - CSSValueInline);
+  EDisplay display = static_cast<EDisplay>(m_valueID - CSSValueInline);
   // TODO(sashab): Check display is a valid EDisplay here.
   return display;
 }
 
 template <>
-inline CSSPrimitiveValue::CSSPrimitiveValue(EEmptyCells e)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(EEmptyCells e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     case EEmptyCells::Show:
-      m_value.valueID = CSSValueShow;
+      m_valueID = CSSValueShow;
       break;
     case EEmptyCells::Hide:
-      m_value.valueID = CSSValueHide;
+      m_valueID = CSSValueHide;
       break;
   }
 }
 
 template <>
-inline EEmptyCells CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline EEmptyCells CSSIdentifierValue::convertTo() const {
+  switch (m_valueID) {
     case CSSValueShow:
       return EEmptyCells::Show;
     case CSSValueHide:
       return EEmptyCells::Hide;
     default:
       break;
   }
 
   ASSERT_NOT_REACHED();
   return EEmptyCells::Show;
 }
 
 template <>
-inline CSSPrimitiveValue::CSSPrimitiveValue(EFlexDirection e)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(EFlexDirection e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     case FlowRow:
-      m_value.valueID = CSSValueRow;
+      m_valueID = CSSValueRow;
       break;
     case FlowRowReverse:
-      m_value.valueID = CSSValueRowReverse;
+      m_valueID = CSSValueRowReverse;
       break;
     case FlowColumn:
-      m_value.valueID = CSSValueColumn;
+      m_valueID = CSSValueColumn;
       break;
     case FlowColumnReverse:
-      m_value.valueID = CSSValueColumnReverse;
+      m_valueID = CSSValueColumnReverse;
       break;
   }
 }
 
 template <>
-inline EFlexDirection CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline EFlexDirection CSSIdentifierValue::convertTo() const {
+  switch (m_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)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(EFlexWrap e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     case FlexNoWrap:
-      m_value.valueID = CSSValueNowrap;
+      m_valueID = CSSValueNowrap;
       break;
     case FlexWrap:
-      m_value.valueID = CSSValueWrap;
+      m_valueID = CSSValueWrap;
       break;
     case FlexWrapReverse:
-      m_value.valueID = CSSValueWrapReverse;
+      m_valueID = CSSValueWrapReverse;
       break;
   }
 }
 
 template <>
-inline EFlexWrap CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline EFlexWrap CSSIdentifierValue::convertTo() const {
+  switch (m_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)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(EFloat e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     case EFloat::None:
-      m_value.valueID = CSSValueNone;
+      m_valueID = CSSValueNone;
       break;
     case EFloat::Left:
-      m_value.valueID = CSSValueLeft;
+      m_valueID = CSSValueLeft;
       break;
     case EFloat::Right:
-      m_value.valueID = CSSValueRight;
+      m_valueID = CSSValueRight;
       break;
   }
 }
 
 template <>
-inline EFloat CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline EFloat CSSIdentifierValue::convertTo() const {
+  switch (m_valueID) {
     case CSSValueLeft:
       return EFloat::Left;
     case CSSValueRight:
       return EFloat::Right;
     case CSSValueNone:
       return EFloat::None;
     default:
       break;
   }
 
   ASSERT_NOT_REACHED();
   return EFloat::None;
 }
 
 template <>
-inline CSSPrimitiveValue::CSSPrimitiveValue(Hyphens e)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(Hyphens e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     case HyphensAuto:
-      m_value.valueID = CSSValueAuto;
+      m_valueID = CSSValueAuto;
       break;
     case HyphensManual:
-      m_value.valueID = CSSValueManual;
+      m_valueID = CSSValueManual;
       break;
     case HyphensNone:
-      m_value.valueID = CSSValueNone;
+      m_valueID = CSSValueNone;
       break;
   }
 }
 
 template <>
-inline Hyphens CSSPrimitiveValue::convertTo() const {
-  DCHECK(isValueID());
-  switch (m_value.valueID) {
+inline Hyphens CSSIdentifierValue::convertTo() const {
+  switch (m_valueID) {
     case CSSValueAuto:
       return HyphensAuto;
     case CSSValueManual:
       return HyphensManual;
     case CSSValueNone:
       return HyphensNone;
     default:
       break;
   }
 
   NOTREACHED();
   return HyphensManual;
 }
 
 template <>
-inline CSSPrimitiveValue::CSSPrimitiveValue(LineBreak e)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(LineBreak e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     case LineBreakAuto:
-      m_value.valueID = CSSValueAuto;
+      m_valueID = CSSValueAuto;
       break;
     case LineBreakLoose:
-      m_value.valueID = CSSValueLoose;
+      m_valueID = CSSValueLoose;
       break;
     case LineBreakNormal:
-      m_value.valueID = CSSValueNormal;
+      m_valueID = CSSValueNormal;
       break;
     case LineBreakStrict:
-      m_value.valueID = CSSValueStrict;
+      m_valueID = CSSValueStrict;
       break;
     case LineBreakAfterWhiteSpace:
-      m_value.valueID = CSSValueAfterWhiteSpace;
+      m_valueID = CSSValueAfterWhiteSpace;
       break;
   }
 }
 
 template <>
-inline LineBreak CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline LineBreak CSSIdentifierValue::convertTo() const {
+  switch (m_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)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(EListStylePosition e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     case ListStylePositionOutside:
-      m_value.valueID = CSSValueOutside;
+      m_valueID = CSSValueOutside;
       break;
     case ListStylePositionInside:
-      m_value.valueID = CSSValueInside;
+      m_valueID = CSSValueInside;
       break;
   }
 }
 
 template <>
-inline EListStylePosition CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline EListStylePosition CSSIdentifierValue::convertTo() const {
+  switch (m_valueID) {
     case CSSValueOutside:
       return ListStylePositionOutside;
     case CSSValueInside:
       return ListStylePositionInside;
     default:
       break;
   }
 
   ASSERT_NOT_REACHED();
   return ListStylePositionOutside;
 }
 
 template <>
-inline CSSPrimitiveValue::CSSPrimitiveValue(EListStyleType e)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(EListStyleType e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     case ArabicIndic:
-      m_value.valueID = CSSValueArabicIndic;
+      m_valueID = CSSValueArabicIndic;
       break;
     case Armenian:
-      m_value.valueID = CSSValueArmenian;
+      m_valueID = CSSValueArmenian;
       break;
     case Bengali:
-      m_value.valueID = CSSValueBengali;
+      m_valueID = CSSValueBengali;
       break;
     case Cambodian:
-      m_value.valueID = CSSValueCambodian;
+      m_valueID = CSSValueCambodian;
       break;
     case Circle:
-      m_value.valueID = CSSValueCircle;
+      m_valueID = CSSValueCircle;
       break;
     case CjkEarthlyBranch:
-      m_value.valueID = CSSValueCjkEarthlyBranch;
+      m_valueID = CSSValueCjkEarthlyBranch;
       break;
     case CjkHeavenlyStem:
-      m_value.valueID = CSSValueCjkHeavenlyStem;
+      m_valueID = CSSValueCjkHeavenlyStem;
       break;
     case CJKIdeographic:
-      m_value.valueID = CSSValueCjkIdeographic;
+      m_valueID = CSSValueCjkIdeographic;
       break;
     case DecimalLeadingZero:
-      m_value.valueID = CSSValueDecimalLeadingZero;
+      m_valueID = CSSValueDecimalLeadingZero;
       break;
     case DecimalListStyle:
-      m_value.valueID = CSSValueDecimal;
+      m_valueID = CSSValueDecimal;
       break;
     case Devanagari:
-      m_value.valueID = CSSValueDevanagari;
+      m_valueID = CSSValueDevanagari;
       break;
     case Disc:
-      m_value.valueID = CSSValueDisc;
+      m_valueID = CSSValueDisc;
       break;
     case EthiopicHalehame:
-      m_value.valueID = CSSValueEthiopicHalehame;
+      m_valueID = CSSValueEthiopicHalehame;
       break;
     case EthiopicHalehameAm:
-      m_value.valueID = CSSValueEthiopicHalehameAm;
+      m_valueID = CSSValueEthiopicHalehameAm;
       break;
     case EthiopicHalehameTiEt:
-      m_value.valueID = CSSValueEthiopicHalehameTiEt;
+      m_valueID = CSSValueEthiopicHalehameTiEt;
       break;
     case EthiopicHalehameTiEr:
-      m_value.valueID = CSSValueEthiopicHalehameTiEr;
+      m_valueID = CSSValueEthiopicHalehameTiEr;
       break;
     case Georgian:
-      m_value.valueID = CSSValueGeorgian;
+      m_valueID = CSSValueGeorgian;
       break;
     case Gujarati:
-      m_value.valueID = CSSValueGujarati;
+      m_valueID = CSSValueGujarati;
       break;
     case Gurmukhi:
-      m_value.valueID = CSSValueGurmukhi;
+      m_valueID = CSSValueGurmukhi;
       break;
     case Hangul:
-      m_value.valueID = CSSValueHangul;
+      m_valueID = CSSValueHangul;
       break;
     case HangulConsonant:
-      m_value.valueID = CSSValueHangulConsonant;
+      m_valueID = CSSValueHangulConsonant;
       break;
     case KoreanHangulFormal:
-      m_value.valueID = CSSValueKoreanHangulFormal;
+      m_valueID = CSSValueKoreanHangulFormal;
       break;
     case KoreanHanjaFormal:
-      m_value.valueID = CSSValueKoreanHanjaFormal;
+      m_valueID = CSSValueKoreanHanjaFormal;
       break;
     case KoreanHanjaInformal:
-      m_value.valueID = CSSValueKoreanHanjaInformal;
+      m_valueID = CSSValueKoreanHanjaInformal;
       break;
     case Hebrew:
-      m_value.valueID = CSSValueHebrew;
+      m_valueID = CSSValueHebrew;
       break;
     case Hiragana:
-      m_value.valueID = CSSValueHiragana;
+      m_valueID = CSSValueHiragana;
       break;
     case HiraganaIroha:
-      m_value.valueID = CSSValueHiraganaIroha;
+      m_valueID = CSSValueHiraganaIroha;
       break;
     case Kannada:
-      m_value.valueID = CSSValueKannada;
+      m_valueID = CSSValueKannada;
       break;
     case Katakana:
-      m_value.valueID = CSSValueKatakana;
+      m_valueID = CSSValueKatakana;
       break;
     case KatakanaIroha:
-      m_value.valueID = CSSValueKatakanaIroha;
+      m_valueID = CSSValueKatakanaIroha;
       break;
     case Khmer:
-      m_value.valueID = CSSValueKhmer;
+      m_valueID = CSSValueKhmer;
       break;
     case Lao:
-      m_value.valueID = CSSValueLao;
+      m_valueID = CSSValueLao;
       break;
     case LowerAlpha:
-      m_value.valueID = CSSValueLowerAlpha;
+      m_valueID = CSSValueLowerAlpha;
       break;
     case LowerArmenian:
-      m_value.valueID = CSSValueLowerArmenian;
+      m_valueID = CSSValueLowerArmenian;
       break;
     case LowerGreek:
-      m_value.valueID = CSSValueLowerGreek;
+      m_valueID = CSSValueLowerGreek;
       break;
     case LowerLatin:
-      m_value.valueID = CSSValueLowerLatin;
+      m_valueID = CSSValueLowerLatin;
       break;
     case LowerRoman:
-      m_value.valueID = CSSValueLowerRoman;
+      m_valueID = CSSValueLowerRoman;
       break;
     case Malayalam:
-      m_value.valueID = CSSValueMalayalam;
+      m_valueID = CSSValueMalayalam;
       break;
     case Mongolian:
-      m_value.valueID = CSSValueMongolian;
+      m_valueID = CSSValueMongolian;
       break;
     case Myanmar:
-      m_value.valueID = CSSValueMyanmar;
+      m_valueID = CSSValueMyanmar;
       break;
     case NoneListStyle:
-      m_value.valueID = CSSValueNone;
+      m_valueID = CSSValueNone;
       break;
     case Oriya:
-      m_value.valueID = CSSValueOriya;
+      m_valueID = CSSValueOriya;
       break;
     case Persian:
-      m_value.valueID = CSSValuePersian;
+      m_valueID = CSSValuePersian;
       break;
     case SimpChineseFormal:
-      m_value.valueID = CSSValueSimpChineseFormal;
+      m_valueID = CSSValueSimpChineseFormal;
       break;
     case SimpChineseInformal:
-      m_value.valueID = CSSValueSimpChineseInformal;
+      m_valueID = CSSValueSimpChineseInformal;
       break;
     case Square:
-      m_value.valueID = CSSValueSquare;
+      m_valueID = CSSValueSquare;
       break;
     case Telugu:
-      m_value.valueID = CSSValueTelugu;
+      m_valueID = CSSValueTelugu;
       break;
     case Thai:
-      m_value.valueID = CSSValueThai;
+      m_valueID = CSSValueThai;
       break;
     case Tibetan:
-      m_value.valueID = CSSValueTibetan;
+      m_valueID = CSSValueTibetan;
       break;
     case TradChineseFormal:
-      m_value.valueID = CSSValueTradChineseFormal;
+      m_valueID = CSSValueTradChineseFormal;
       break;
     case TradChineseInformal:
-      m_value.valueID = CSSValueTradChineseInformal;
+      m_valueID = CSSValueTradChineseInformal;
       break;
     case UpperAlpha:
-      m_value.valueID = CSSValueUpperAlpha;
+      m_valueID = CSSValueUpperAlpha;
       break;
     case UpperArmenian:
-      m_value.valueID = CSSValueUpperArmenian;
+      m_valueID = CSSValueUpperArmenian;
       break;
     case UpperLatin:
-      m_value.valueID = CSSValueUpperLatin;
+      m_valueID = CSSValueUpperLatin;
       break;
     case UpperRoman:
-      m_value.valueID = CSSValueUpperRoman;
+      m_valueID = CSSValueUpperRoman;
       break;
     case Urdu:
-      m_value.valueID = CSSValueUrdu;
+      m_valueID = CSSValueUrdu;
       break;
   }
 }
 
 template <>
-inline EListStyleType CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline EListStyleType CSSIdentifierValue::convertTo() const {
+  switch (m_valueID) {
     case CSSValueNone:
       return NoneListStyle;
     default:
-      return static_cast<EListStyleType>(m_value.valueID - CSSValueDisc);
+      return static_cast<EListStyleType>(m_valueID - CSSValueDisc);
   }
 }
 
 template <>
-inline CSSPrimitiveValue::CSSPrimitiveValue(EMarginCollapse e)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(EMarginCollapse e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     case MarginCollapseCollapse:
-      m_value.valueID = CSSValueCollapse;
+      m_valueID = CSSValueCollapse;
       break;
     case MarginCollapseSeparate:
-      m_value.valueID = CSSValueSeparate;
+      m_valueID = CSSValueSeparate;
       break;
     case MarginCollapseDiscard:
-      m_value.valueID = CSSValueDiscard;
+      m_valueID = CSSValueDiscard;
       break;
   }
 }
 
 template <>
-inline EMarginCollapse CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline EMarginCollapse CSSIdentifierValue::convertTo() const {
+  switch (m_valueID) {
     case CSSValueCollapse:
       return MarginCollapseCollapse;
     case CSSValueSeparate:
       return MarginCollapseSeparate;
     case CSSValueDiscard:
       return MarginCollapseDiscard;
     default:
       break;
   }
 
   ASSERT_NOT_REACHED();
   return MarginCollapseCollapse;
 }
 
 template <>
-inline CSSPrimitiveValue::CSSPrimitiveValue(EOverflow e)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(EOverflow e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     case OverflowVisible:
-      m_value.valueID = CSSValueVisible;
+      m_valueID = CSSValueVisible;
       break;
     case OverflowHidden:
-      m_value.valueID = CSSValueHidden;
+      m_valueID = CSSValueHidden;
       break;
     case OverflowScroll:
-      m_value.valueID = CSSValueScroll;
+      m_valueID = CSSValueScroll;
       break;
     case OverflowAuto:
-      m_value.valueID = CSSValueAuto;
+      m_valueID = CSSValueAuto;
       break;
     case OverflowOverlay:
-      m_value.valueID = CSSValueOverlay;
+      m_valueID = CSSValueOverlay;
       break;
     case OverflowPagedX:
-      m_value.valueID = CSSValueWebkitPagedX;
+      m_valueID = CSSValueWebkitPagedX;
       break;
     case OverflowPagedY:
-      m_value.valueID = CSSValueWebkitPagedY;
+      m_valueID = CSSValueWebkitPagedY;
       break;
   }
 }
 
 template <>
-inline EOverflow CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline EOverflow CSSIdentifierValue::convertTo() const {
+  switch (m_valueID) {
     case CSSValueVisible:
       return OverflowVisible;
     case CSSValueHidden:
       return OverflowHidden;
     case CSSValueScroll:
       return OverflowScroll;
     case CSSValueAuto:
       return OverflowAuto;
     case CSSValueOverlay:
       return OverflowOverlay;
     case CSSValueWebkitPagedX:
       return OverflowPagedX;
     case CSSValueWebkitPagedY:
       return OverflowPagedY;
     default:
       break;
   }
 
   ASSERT_NOT_REACHED();
   return OverflowVisible;
 }
 
 template <>
-inline CSSPrimitiveValue::CSSPrimitiveValue(EBreak e)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(EBreak e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     default:
       ASSERT_NOT_REACHED();
     case BreakAuto:
-      m_value.valueID = CSSValueAuto;
+      m_valueID = CSSValueAuto;
       break;
     case BreakAlways:
-      m_value.valueID = CSSValueAlways;
+      m_valueID = CSSValueAlways;
       break;
     case BreakAvoid:
-      m_value.valueID = CSSValueAvoid;
+      m_valueID = CSSValueAvoid;
       break;
     case BreakAvoidPage:
-      m_value.valueID = CSSValueAvoidPage;
+      m_valueID = CSSValueAvoidPage;
       break;
     case BreakPage:
-      m_value.valueID = CSSValuePage;
+      m_valueID = CSSValuePage;
       break;
     case BreakLeft:
-      m_value.valueID = CSSValueLeft;
+      m_valueID = CSSValueLeft;
       break;
     case BreakRight:
-      m_value.valueID = CSSValueRight;
+      m_valueID = CSSValueRight;
       break;
     case BreakRecto:
-      m_value.valueID = CSSValueRecto;
+      m_valueID = CSSValueRecto;
       break;
     case BreakVerso:
-      m_value.valueID = CSSValueVerso;
+      m_valueID = CSSValueVerso;
       break;
     case BreakAvoidColumn:
-      m_value.valueID = CSSValueAvoidColumn;
+      m_valueID = CSSValueAvoidColumn;
       break;
     case BreakColumn:
-      m_value.valueID = CSSValueColumn;
+      m_valueID = CSSValueColumn;
       break;
   }
 }
 
 template <>
-inline EBreak CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline EBreak CSSIdentifierValue::convertTo() const {
+  switch (m_valueID) {
     default:
       ASSERT_NOT_REACHED();
     case CSSValueAuto:
       return BreakAuto;
     case CSSValueAvoid:
       return BreakAvoid;
     case CSSValueAlways:
       return BreakAlways;
     case CSSValueAvoidPage:
       return BreakAvoidPage;
     case CSSValuePage:
       return BreakPage;
     case CSSValueLeft:
       return BreakLeft;
     case CSSValueRight:
       return BreakRight;
     case CSSValueRecto:
       return BreakRecto;
     case CSSValueVerso:
       return BreakVerso;
     case CSSValueAvoidColumn:
       return BreakAvoidColumn;
     case CSSValueColumn:
       return BreakColumn;
   }
 }
 
 template <>
-inline CSSPrimitiveValue::CSSPrimitiveValue(EPosition e)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(EPosition e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     case StaticPosition:
-      m_value.valueID = CSSValueStatic;
+      m_valueID = CSSValueStatic;
       break;
     case RelativePosition:
-      m_value.valueID = CSSValueRelative;
+      m_valueID = CSSValueRelative;
       break;
     case AbsolutePosition:
-      m_value.valueID = CSSValueAbsolute;
+      m_valueID = CSSValueAbsolute;
       break;
     case FixedPosition:
-      m_value.valueID = CSSValueFixed;
+      m_valueID = CSSValueFixed;
       break;
     case StickyPosition:
-      m_value.valueID = CSSValueSticky;
+      m_valueID = CSSValueSticky;
       break;
   }
 }
 
 template <>
-inline EPosition CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline EPosition CSSIdentifierValue::convertTo() const {
+  switch (m_valueID) {
     case CSSValueStatic:
       return StaticPosition;
     case CSSValueRelative:
       return RelativePosition;
     case CSSValueAbsolute:
       return AbsolutePosition;
     case CSSValueFixed:
       return FixedPosition;
     case CSSValueSticky:
       return StickyPosition;
     default:
       break;
   }
 
   ASSERT_NOT_REACHED();
   return StaticPosition;
 }
 
 template <>
-inline CSSPrimitiveValue::CSSPrimitiveValue(EResize e)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(EResize e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     case RESIZE_BOTH:
-      m_value.valueID = CSSValueBoth;
+      m_valueID = CSSValueBoth;
       break;
     case RESIZE_HORIZONTAL:
-      m_value.valueID = CSSValueHorizontal;
+      m_valueID = CSSValueHorizontal;
       break;
     case RESIZE_VERTICAL:
-      m_value.valueID = CSSValueVertical;
+      m_valueID = CSSValueVertical;
       break;
     case RESIZE_NONE:
-      m_value.valueID = CSSValueNone;
+      m_valueID = CSSValueNone;
       break;
   }
 }
 
 template <>
-inline EResize CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline EResize CSSIdentifierValue::convertTo() const {
+  switch (m_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)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(ETableLayout e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     case TableLayoutAuto:
-      m_value.valueID = CSSValueAuto;
+      m_valueID = CSSValueAuto;
       break;
     case TableLayoutFixed:
-      m_value.valueID = CSSValueFixed;
+      m_valueID = CSSValueFixed;
       break;
   }
 }
 
 template <>
-inline ETableLayout CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline ETableLayout CSSIdentifierValue::convertTo() const {
+  switch (m_valueID) {
     case CSSValueFixed:
       return TableLayoutFixed;
     case CSSValueAuto:
       return TableLayoutAuto;
     default:
       break;
   }
 
   ASSERT_NOT_REACHED();
   return TableLayoutAuto;
 }
 
 template <>
-inline CSSPrimitiveValue::CSSPrimitiveValue(ETextAlign e)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(ETextAlign e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     case TASTART:
-      m_value.valueID = CSSValueStart;
+      m_valueID = CSSValueStart;
       break;
     case TAEND:
-      m_value.valueID = CSSValueEnd;
+      m_valueID = CSSValueEnd;
       break;
     case LEFT:
-      m_value.valueID = CSSValueLeft;
+      m_valueID = CSSValueLeft;
       break;
     case RIGHT:
-      m_value.valueID = CSSValueRight;
+      m_valueID = CSSValueRight;
       break;
     case CENTER:
-      m_value.valueID = CSSValueCenter;
+      m_valueID = CSSValueCenter;
       break;
     case JUSTIFY:
-      m_value.valueID = CSSValueJustify;
+      m_valueID = CSSValueJustify;
       break;
     case WEBKIT_LEFT:
-      m_value.valueID = CSSValueWebkitLeft;
+      m_valueID = CSSValueWebkitLeft;
       break;
     case WEBKIT_RIGHT:
-      m_value.valueID = CSSValueWebkitRight;
+      m_valueID = CSSValueWebkitRight;
       break;
     case WEBKIT_CENTER:
-      m_value.valueID = CSSValueWebkitCenter;
+      m_valueID = CSSValueWebkitCenter;
       break;
   }
 }
 
 template <>
-inline ETextAlign CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline ETextAlign CSSIdentifierValue::convertTo() const {
+  switch (m_valueID) {
     case CSSValueWebkitAuto:  // Legacy -webkit-auto. Eqiuvalent to start.
     case CSSValueStart:
       return TASTART;
     case CSSValueEnd:
       return TAEND;
     case CSSValueInternalCenter:
       return CENTER;
     default:
-      return static_cast<ETextAlign>(m_value.valueID - CSSValueLeft);
+      return static_cast<ETextAlign>(m_valueID - CSSValueLeft);
   }
 }
 
 template <>
-inline CSSPrimitiveValue::CSSPrimitiveValue(TextAlignLast e)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(TextAlignLast e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     case TextAlignLastStart:
-      m_value.valueID = CSSValueStart;
+      m_valueID = CSSValueStart;
       break;
     case TextAlignLastEnd:
-      m_value.valueID = CSSValueEnd;
+      m_valueID = CSSValueEnd;
       break;
     case TextAlignLastLeft:
-      m_value.valueID = CSSValueLeft;
+      m_valueID = CSSValueLeft;
       break;
     case TextAlignLastRight:
-      m_value.valueID = CSSValueRight;
+      m_valueID = CSSValueRight;
       break;
     case TextAlignLastCenter:
-      m_value.valueID = CSSValueCenter;
+      m_valueID = CSSValueCenter;
       break;
     case TextAlignLastJustify:
-      m_value.valueID = CSSValueJustify;
+      m_valueID = CSSValueJustify;
       break;
     case TextAlignLastAuto:
-      m_value.valueID = CSSValueAuto;
+      m_valueID = CSSValueAuto;
       break;
   }
 }
 
 template <>
-inline TextAlignLast CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline TextAlignLast CSSIdentifierValue::convertTo() const {
+  switch (m_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)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(TextJustify e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     case TextJustifyAuto:
-      m_value.valueID = CSSValueAuto;
+      m_valueID = CSSValueAuto;
       break;
     case TextJustifyNone:
-      m_value.valueID = CSSValueNone;
+      m_valueID = CSSValueNone;
       break;
     case TextJustifyInterWord:
-      m_value.valueID = CSSValueInterWord;
+      m_valueID = CSSValueInterWord;
       break;
     case TextJustifyDistribute:
-      m_value.valueID = CSSValueDistribute;
+      m_valueID = CSSValueDistribute;
       break;
   }
 }
 
 template <>
-inline TextJustify CSSPrimitiveValue::convertTo() const {
-  switch (m_value.valueID) {
+inline TextJustify CSSIdentifierValue::convertTo() const {
+  switch (m_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 TextDecoration CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline TextDecoration CSSIdentifierValue::convertTo() const {
+  switch (m_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 TextDecorationStyle CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline TextDecorationStyle CSSIdentifierValue::convertTo() const {
+  switch (m_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)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(TextUnderlinePosition e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     case TextUnderlinePositionAuto:
-      m_value.valueID = CSSValueAuto;
+      m_valueID = CSSValueAuto;
       break;
     case TextUnderlinePositionUnder:
-      m_value.valueID = CSSValueUnder;
+      m_valueID = CSSValueUnder;
       break;
   }
 
   // FIXME: Implement support for 'under left' and 'under right' values.
 }
 
 template <>
-inline TextUnderlinePosition CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline TextUnderlinePosition CSSIdentifierValue::convertTo() const {
+  switch (m_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)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(ETextSecurity e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     case TSNONE:
-      m_value.valueID = CSSValueNone;
+      m_valueID = CSSValueNone;
       break;
     case TSDISC:
-      m_value.valueID = CSSValueDisc;
+      m_valueID = CSSValueDisc;
       break;
     case TSCIRCLE:
-      m_value.valueID = CSSValueCircle;
+      m_valueID = CSSValueCircle;
       break;
     case TSSQUARE:
-      m_value.valueID = CSSValueSquare;
+      m_valueID = CSSValueSquare;
       break;
   }
 }
 
 template <>
-inline ETextSecurity CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline ETextSecurity CSSIdentifierValue::convertTo() const {
+  switch (m_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)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(ETextTransform e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     case CAPITALIZE:
-      m_value.valueID = CSSValueCapitalize;
+      m_valueID = CSSValueCapitalize;
       break;
     case UPPERCASE:
-      m_value.valueID = CSSValueUppercase;
+      m_valueID = CSSValueUppercase;
       break;
     case LOWERCASE:
-      m_value.valueID = CSSValueLowercase;
+      m_valueID = CSSValueLowercase;
       break;
     case TTNONE:
-      m_value.valueID = CSSValueNone;
+      m_valueID = CSSValueNone;
       break;
   }
 }
 
 template <>
-inline ETextTransform CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline ETextTransform CSSIdentifierValue::convertTo() const {
+  switch (m_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)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(EUnicodeBidi e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     case UBNormal:
-      m_value.valueID = CSSValueNormal;
+      m_valueID = CSSValueNormal;
       break;
     case Embed:
-      m_value.valueID = CSSValueEmbed;
+      m_valueID = CSSValueEmbed;
       break;
     case Override:
-      m_value.valueID = CSSValueBidiOverride;
+      m_valueID = CSSValueBidiOverride;
       break;
     case Isolate:
-      m_value.valueID = CSSValueIsolate;
+      m_valueID = CSSValueIsolate;
       break;
     case IsolateOverride:
-      m_value.valueID = CSSValueIsolateOverride;
+      m_valueID = CSSValueIsolateOverride;
       break;
     case Plaintext:
-      m_value.valueID = CSSValuePlaintext;
+      m_valueID = CSSValuePlaintext;
       break;
   }
 }
 
 template <>
-inline EUnicodeBidi CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline EUnicodeBidi CSSIdentifierValue::convertTo() const {
+  switch (m_valueID) {
     case CSSValueNormal:
       return UBNormal;
     case CSSValueEmbed:
       return Embed;
     case CSSValueBidiOverride:
       return Override;
     case CSSValueIsolate:
     case CSSValueWebkitIsolate:
       return Isolate;
     case CSSValueIsolateOverride:
     case CSSValueWebkitIsolateOverride:
       return IsolateOverride;
     case CSSValuePlaintext:
     case CSSValueWebkitPlaintext:
       return Plaintext;
     default:
       break;
   }
 
   ASSERT_NOT_REACHED();
   return UBNormal;
 }
 
 template <>
-inline CSSPrimitiveValue::CSSPrimitiveValue(EUserDrag e)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(EUserDrag e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     case DRAG_AUTO:
-      m_value.valueID = CSSValueAuto;
+      m_valueID = CSSValueAuto;
       break;
     case DRAG_NONE:
-      m_value.valueID = CSSValueNone;
+      m_valueID = CSSValueNone;
       break;
     case DRAG_ELEMENT:
-      m_value.valueID = CSSValueElement;
+      m_valueID = CSSValueElement;
       break;
     default:
       break;
   }
 }
 
 template <>
-inline EUserDrag CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline EUserDrag CSSIdentifierValue::convertTo() const {
+  switch (m_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)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(EUserModify e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     case READ_ONLY:
-      m_value.valueID = CSSValueReadOnly;
+      m_valueID = CSSValueReadOnly;
       break;
     case READ_WRITE:
-      m_value.valueID = CSSValueReadWrite;
+      m_valueID = CSSValueReadWrite;
       break;
     case READ_WRITE_PLAINTEXT_ONLY:
-      m_value.valueID = CSSValueReadWritePlaintextOnly;
+      m_valueID = CSSValueReadWritePlaintextOnly;
       break;
   }
 }
 
 template <>
-inline EUserModify CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline EUserModify CSSIdentifierValue::convertTo() const {
+  switch (m_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)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(EUserSelect e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     case SELECT_NONE:
-      m_value.valueID = CSSValueNone;
+      m_valueID = CSSValueNone;
       break;
     case SELECT_TEXT:
-      m_value.valueID = CSSValueText;
+      m_valueID = CSSValueText;
       break;
     case SELECT_ALL:
-      m_value.valueID = CSSValueAll;
+      m_valueID = CSSValueAll;
       break;
   }
 }
 
 template <>
-inline EUserSelect CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline EUserSelect CSSIdentifierValue::convertTo() const {
+  switch (m_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)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(EVerticalAlign a)
+    : CSSValue(IdentifierClass) {
   switch (a) {
     case VerticalAlignTop:
-      m_value.valueID = CSSValueTop;
+      m_valueID = CSSValueTop;
       break;
     case VerticalAlignBottom:
-      m_value.valueID = CSSValueBottom;
+      m_valueID = CSSValueBottom;
       break;
     case VerticalAlignMiddle:
-      m_value.valueID = CSSValueMiddle;
+      m_valueID = CSSValueMiddle;
       break;
     case VerticalAlignBaseline:
-      m_value.valueID = CSSValueBaseline;
+      m_valueID = CSSValueBaseline;
       break;
     case VerticalAlignTextBottom:
-      m_value.valueID = CSSValueTextBottom;
+      m_valueID = CSSValueTextBottom;
       break;
     case VerticalAlignTextTop:
-      m_value.valueID = CSSValueTextTop;
+      m_valueID = CSSValueTextTop;
       break;
     case VerticalAlignSub:
-      m_value.valueID = CSSValueSub;
+      m_valueID = CSSValueSub;
       break;
     case VerticalAlignSuper:
-      m_value.valueID = CSSValueSuper;
+      m_valueID = CSSValueSuper;
       break;
     case VerticalAlignBaselineMiddle:
-      m_value.valueID = CSSValueWebkitBaselineMiddle;
+      m_valueID = CSSValueWebkitBaselineMiddle;
       break;
     case VerticalAlignLength:
-      m_value.valueID = CSSValueInvalid;
+      m_valueID = CSSValueInvalid;
   }
 }
 
 template <>
-inline EVerticalAlign CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline EVerticalAlign CSSIdentifierValue::convertTo() const {
+  switch (m_valueID) {
     case CSSValueTop:
       return VerticalAlignTop;
     case CSSValueBottom:
       return VerticalAlignBottom;
     case CSSValueMiddle:
       return VerticalAlignMiddle;
     case CSSValueBaseline:
       return VerticalAlignBaseline;
     case CSSValueTextBottom:
       return VerticalAlignTextBottom;
     case CSSValueTextTop:
       return VerticalAlignTextTop;
     case CSSValueSub:
       return VerticalAlignSub;
     case CSSValueSuper:
       return VerticalAlignSuper;
     case CSSValueWebkitBaselineMiddle:
       return VerticalAlignBaselineMiddle;
     default:
       break;
   }
 
   ASSERT_NOT_REACHED();
   return VerticalAlignTop;
 }
 
 template <>
-inline CSSPrimitiveValue::CSSPrimitiveValue(EVisibility e)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(EVisibility e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     case EVisibility::Visible:
-      m_value.valueID = CSSValueVisible;
+      m_valueID = CSSValueVisible;
       break;
     case EVisibility::Hidden:
-      m_value.valueID = CSSValueHidden;
+      m_valueID = CSSValueHidden;
       break;
     case EVisibility::Collapse:
-      m_value.valueID = CSSValueCollapse;
+      m_valueID = CSSValueCollapse;
       break;
   }
 }
 
 template <>
-inline EVisibility CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline EVisibility CSSIdentifierValue::convertTo() const {
+  switch (m_valueID) {
     case CSSValueHidden:
       return EVisibility::Hidden;
     case CSSValueVisible:
       return EVisibility::Visible;
     case CSSValueCollapse:
       return EVisibility::Collapse;
     default:
       break;
   }
 
   ASSERT_NOT_REACHED();
   return EVisibility::Visible;
 }
 
 template <>
-inline CSSPrimitiveValue::CSSPrimitiveValue(EWhiteSpace e)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(EWhiteSpace e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     case NORMAL:
-      m_value.valueID = CSSValueNormal;
+      m_valueID = CSSValueNormal;
       break;
     case PRE:
-      m_value.valueID = CSSValuePre;
+      m_valueID = CSSValuePre;
       break;
     case PRE_WRAP:
-      m_value.valueID = CSSValuePreWrap;
+      m_valueID = CSSValuePreWrap;
       break;
     case PRE_LINE:
-      m_value.valueID = CSSValuePreLine;
+      m_valueID = CSSValuePreLine;
       break;
     case NOWRAP:
-      m_value.valueID = CSSValueNowrap;
+      m_valueID = CSSValueNowrap;
       break;
     case KHTML_NOWRAP:
-      m_value.valueID = CSSValueWebkitNowrap;
+      m_valueID = CSSValueWebkitNowrap;
       break;
   }
 }
 
 template <>
-inline EWhiteSpace CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline EWhiteSpace CSSIdentifierValue::convertTo() const {
+  switch (m_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)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(EWordBreak e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     case NormalWordBreak:
-      m_value.valueID = CSSValueNormal;
+      m_valueID = CSSValueNormal;
       break;
     case BreakAllWordBreak:
-      m_value.valueID = CSSValueBreakAll;
+      m_valueID = CSSValueBreakAll;
       break;
     case BreakWordBreak:
-      m_value.valueID = CSSValueBreakWord;
+      m_valueID = CSSValueBreakWord;
       break;
     case KeepAllWordBreak:
-      m_value.valueID = CSSValueKeepAll;
+      m_valueID = CSSValueKeepAll;
       break;
   }
 }
 
 template <>
-inline EWordBreak CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline EWordBreak CSSIdentifierValue::convertTo() const {
+  switch (m_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(EOverflowAnchor e)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(EOverflowAnchor e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     case AnchorVisible:
-      m_value.valueID = CSSValueVisible;
+      m_valueID = CSSValueVisible;
       break;
     case AnchorNone:
-      m_value.valueID = CSSValueNone;
+      m_valueID = CSSValueNone;
       break;
     case AnchorAuto:
-      m_value.valueID = CSSValueAuto;
+      m_valueID = CSSValueAuto;
       break;
   }
 }
 
 template <>
-inline EOverflowAnchor CSSPrimitiveValue::convertTo() const {
-  DCHECK(isValueID());
-  switch (m_value.valueID) {
+inline EOverflowAnchor CSSIdentifierValue::convertTo() const {
+  switch (m_valueID) {
     case CSSValueVisible:
       return AnchorVisible;
     case CSSValueNone:
       return AnchorNone;
     case CSSValueAuto:
       return AnchorAuto;
     default:
       break;
   }
 
   NOTREACHED();
   return AnchorNone;
 }
 
 template <>
-inline CSSPrimitiveValue::CSSPrimitiveValue(EOverflowWrap e)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(EOverflowWrap e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     case NormalOverflowWrap:
-      m_value.valueID = CSSValueNormal;
+      m_valueID = CSSValueNormal;
       break;
     case BreakOverflowWrap:
-      m_value.valueID = CSSValueBreakWord;
+      m_valueID = CSSValueBreakWord;
       break;
   }
 }
 
 template <>
-inline EOverflowWrap CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline EOverflowWrap CSSIdentifierValue::convertTo() const {
+  switch (m_valueID) {
     case CSSValueBreakWord:
       return BreakOverflowWrap;
     case CSSValueNormal:
       return NormalOverflowWrap;
     default:
       break;
   }
 
   ASSERT_NOT_REACHED();
   return NormalOverflowWrap;
 }
 
 template <>
-inline CSSPrimitiveValue::CSSPrimitiveValue(TextDirection e)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(TextDirection e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     case LTR:
-      m_value.valueID = CSSValueLtr;
+      m_valueID = CSSValueLtr;
       break;
     case RTL:
-      m_value.valueID = CSSValueRtl;
+      m_valueID = CSSValueRtl;
       break;
   }
 }
 
 template <>
-inline TextDirection CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline TextDirection CSSIdentifierValue::convertTo() const {
+  switch (m_valueID) {
     case CSSValueLtr:
       return LTR;
     case CSSValueRtl:
       return RTL;
     default:
       break;
   }
 
   ASSERT_NOT_REACHED();
   return LTR;
 }
 
 template <>
-inline CSSPrimitiveValue::CSSPrimitiveValue(WritingMode e)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(WritingMode e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     case TopToBottomWritingMode:
-      m_value.valueID = CSSValueHorizontalTb;
+      m_valueID = CSSValueHorizontalTb;
       break;
     case RightToLeftWritingMode:
-      m_value.valueID = CSSValueVerticalRl;
+      m_valueID = CSSValueVerticalRl;
       break;
     case LeftToRightWritingMode:
-      m_value.valueID = CSSValueVerticalLr;
+      m_valueID = CSSValueVerticalLr;
       break;
   }
 }
 
 template <>
-inline WritingMode CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline WritingMode CSSIdentifierValue::convertTo() const {
+  switch (m_valueID) {
     case CSSValueHorizontalTb:
     case CSSValueLr:
     case CSSValueLrTb:
     case CSSValueRl:
     case CSSValueRlTb:
       return TopToBottomWritingMode;
     case CSSValueVerticalRl:
     case CSSValueTb:
     case CSSValueTbRl:
       return RightToLeftWritingMode;
     case CSSValueVerticalLr:
       return LeftToRightWritingMode;
     default:
       break;
   }
 
   ASSERT_NOT_REACHED();
   return TopToBottomWritingMode;
 }
 
 template <>
-inline CSSPrimitiveValue::CSSPrimitiveValue(TextCombine e)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(TextCombine e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     case TextCombineNone:
-      m_value.valueID = CSSValueNone;
+      m_valueID = CSSValueNone;
       break;
     case TextCombineAll:
-      m_value.valueID = CSSValueAll;
+      m_valueID = CSSValueAll;
       break;
   }
 }
 
 template <>
-inline TextCombine CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline TextCombine CSSIdentifierValue::convertTo() const {
+  switch (m_valueID) {
     case CSSValueNone:
       return TextCombineNone;
     case CSSValueAll:
     case CSSValueHorizontal:  // -webkit-text-combine
       return TextCombineAll;
     default:
       break;
   }
 
   ASSERT_NOT_REACHED();
   return TextCombineNone;
 }
 
 template <>
-inline CSSPrimitiveValue::CSSPrimitiveValue(RubyPosition position)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(RubyPosition position)
+    : CSSValue(IdentifierClass) {
   switch (position) {
     case RubyPositionBefore:
-      m_value.valueID = CSSValueBefore;
+      m_valueID = CSSValueBefore;
       break;
     case RubyPositionAfter:
-      m_value.valueID = CSSValueAfter;
+      m_valueID = CSSValueAfter;
       break;
   }
 }
 
 template <>
-inline RubyPosition CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline RubyPosition CSSIdentifierValue::convertTo() const {
+  switch (m_valueID) {
     case CSSValueBefore:
       return RubyPositionBefore;
     case CSSValueAfter:
       return RubyPositionAfter;
     default:
       break;
   }
 
   ASSERT_NOT_REACHED();
   return RubyPositionBefore;
 }
 
 template <>
-inline CSSPrimitiveValue::CSSPrimitiveValue(TextEmphasisPosition position)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(TextEmphasisPosition position)
+    : CSSValue(IdentifierClass) {
   switch (position) {
     case TextEmphasisPositionOver:
-      m_value.valueID = CSSValueOver;
+      m_valueID = CSSValueOver;
       break;
     case TextEmphasisPositionUnder:
-      m_value.valueID = CSSValueUnder;
+      m_valueID = CSSValueUnder;
       break;
   }
 }
 
 template <>
-inline TextEmphasisPosition CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline TextEmphasisPosition CSSIdentifierValue::convertTo() const {
+  switch (m_valueID) {
     case CSSValueOver:
       return TextEmphasisPositionOver;
     case CSSValueUnder:
       return TextEmphasisPositionUnder;
     default:
       break;
   }
 
   ASSERT_NOT_REACHED();
   return TextEmphasisPositionOver;
 }
 
 template <>
-inline CSSPrimitiveValue::CSSPrimitiveValue(TextOverflow overflow)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(TextOverflow overflow)
+    : CSSValue(IdentifierClass) {
   switch (overflow) {
     case TextOverflowClip:
-      m_value.valueID = CSSValueClip;
+      m_valueID = CSSValueClip;
       break;
     case TextOverflowEllipsis:
-      m_value.valueID = CSSValueEllipsis;
+      m_valueID = CSSValueEllipsis;
       break;
   }
 }
 
 template <>
-inline TextOverflow CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline TextOverflow CSSIdentifierValue::convertTo() const {
+  switch (m_valueID) {
     case CSSValueClip:
       return TextOverflowClip;
     case CSSValueEllipsis:
       return TextOverflowEllipsis;
     default:
       break;
   }
 
   ASSERT_NOT_REACHED();
   return TextOverflowClip;
 }
 
 template <>
-inline CSSPrimitiveValue::CSSPrimitiveValue(TextEmphasisFill fill)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(TextEmphasisFill fill)
+    : CSSValue(IdentifierClass) {
   switch (fill) {
     case TextEmphasisFillFilled:
-      m_value.valueID = CSSValueFilled;
+      m_valueID = CSSValueFilled;
       break;
     case TextEmphasisFillOpen:
-      m_value.valueID = CSSValueOpen;
+      m_valueID = CSSValueOpen;
       break;
   }
 }
 
 template <>
-inline TextEmphasisFill CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline TextEmphasisFill CSSIdentifierValue::convertTo() const {
+  switch (m_valueID) {
     case CSSValueFilled:
       return TextEmphasisFillFilled;
     case CSSValueOpen:
       return TextEmphasisFillOpen;
     default:
       break;
   }
 
   ASSERT_NOT_REACHED();
   return TextEmphasisFillFilled;
 }
 
 template <>
-inline CSSPrimitiveValue::CSSPrimitiveValue(TextEmphasisMark mark)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(TextEmphasisMark mark)
+    : CSSValue(IdentifierClass) {
   switch (mark) {
     case TextEmphasisMarkDot:
-      m_value.valueID = CSSValueDot;
+      m_valueID = CSSValueDot;
       break;
     case TextEmphasisMarkCircle:
-      m_value.valueID = CSSValueCircle;
+      m_valueID = CSSValueCircle;
       break;
     case TextEmphasisMarkDoubleCircle:
-      m_value.valueID = CSSValueDoubleCircle;
+      m_valueID = CSSValueDoubleCircle;
       break;
     case TextEmphasisMarkTriangle:
-      m_value.valueID = CSSValueTriangle;
+      m_valueID = CSSValueTriangle;
       break;
     case TextEmphasisMarkSesame:
-      m_value.valueID = CSSValueSesame;
+      m_valueID = CSSValueSesame;
       break;
     case TextEmphasisMarkNone:
     case TextEmphasisMarkAuto:
     case TextEmphasisMarkCustom:
       ASSERT_NOT_REACHED();
-      m_value.valueID = CSSValueNone;
+      m_valueID = CSSValueNone;
       break;
   }
 }
 
 template <>
-inline TextEmphasisMark CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline TextEmphasisMark CSSIdentifierValue::convertTo() const {
+  switch (m_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)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(TextOrientation e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     case TextOrientationSideways:
-      m_value.valueID = CSSValueSideways;
+      m_valueID = CSSValueSideways;
       break;
     case TextOrientationMixed:
-      m_value.valueID = CSSValueMixed;
+      m_valueID = CSSValueMixed;
       break;
     case TextOrientationUpright:
-      m_value.valueID = CSSValueUpright;
+      m_valueID = CSSValueUpright;
       break;
   }
 }
 
 template <>
-inline TextOrientation CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline TextOrientation CSSIdentifierValue::convertTo() const {
+  switch (m_valueID) {
     case CSSValueSideways:
     case CSSValueSidewaysRight:
       return TextOrientationSideways;
     case CSSValueMixed:
     case CSSValueVerticalRight:  // -webkit-text-orientation
       return TextOrientationMixed;
     case CSSValueUpright:
       return TextOrientationUpright;
     default:
       break;
   }
 
   ASSERT_NOT_REACHED();
   return TextOrientationMixed;
 }
 
 template <>
-inline CSSPrimitiveValue::CSSPrimitiveValue(EPointerEvents e)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(EPointerEvents e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     case PE_NONE:
-      m_value.valueID = CSSValueNone;
+      m_valueID = CSSValueNone;
       break;
     case PE_STROKE:
-      m_value.valueID = CSSValueStroke;
+      m_valueID = CSSValueStroke;
       break;
     case PE_FILL:
-      m_value.valueID = CSSValueFill;
+      m_valueID = CSSValueFill;
       break;
     case PE_PAINTED:
-      m_value.valueID = CSSValuePainted;
+      m_valueID = CSSValuePainted;
       break;
     case PE_VISIBLE:
-      m_value.valueID = CSSValueVisible;
+      m_valueID = CSSValueVisible;
       break;
     case PE_VISIBLE_STROKE:
-      m_value.valueID = CSSValueVisibleStroke;
+      m_valueID = CSSValueVisibleStroke;
       break;
     case PE_VISIBLE_FILL:
-      m_value.valueID = CSSValueVisibleFill;
+      m_valueID = CSSValueVisibleFill;
       break;
     case PE_VISIBLE_PAINTED:
-      m_value.valueID = CSSValueVisiblePainted;
+      m_valueID = CSSValueVisiblePainted;
       break;
     case PE_AUTO:
-      m_value.valueID = CSSValueAuto;
+      m_valueID = CSSValueAuto;
       break;
     case PE_ALL:
-      m_value.valueID = CSSValueAll;
+      m_valueID = CSSValueAll;
       break;
     case PE_BOUNDINGBOX:
-      m_value.valueID = CSSValueBoundingBox;
+      m_valueID = CSSValueBoundingBox;
       break;
   }
 }
 
 template <>
-inline EPointerEvents CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline EPointerEvents CSSIdentifierValue::convertTo() const {
+  switch (m_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 11 matching lines @@
       return PE_BOUNDINGBOX;
     default:
       break;
   }
 
   ASSERT_NOT_REACHED();
   return PE_ALL;
 }
 
 template <>
-inline CSSPrimitiveValue::CSSPrimitiveValue(FontDescription::Kerning kerning)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(FontDescription::Kerning kerning)
+    : CSSValue(IdentifierClass) {
   switch (kerning) {
     case FontDescription::AutoKerning:
-      m_value.valueID = CSSValueAuto;
+      m_valueID = CSSValueAuto;
       return;
     case FontDescription::NormalKerning:
-      m_value.valueID = CSSValueNormal;
+      m_valueID = CSSValueNormal;
       return;
     case FontDescription::NoneKerning:
-      m_value.valueID = CSSValueNone;
+      m_valueID = CSSValueNone;
       return;
   }
 
   ASSERT_NOT_REACHED();
-  m_value.valueID = CSSValueAuto;
+  m_valueID = CSSValueAuto;
 }
 
 template <>
-inline FontDescription::Kerning CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline FontDescription::Kerning CSSIdentifierValue::convertTo() const {
+  switch (m_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)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(ObjectFit fit)
+    : CSSValue(IdentifierClass) {
   switch (fit) {
     case ObjectFitFill:
-      m_value.valueID = CSSValueFill;
+      m_valueID = CSSValueFill;
       break;
     case ObjectFitContain:
-      m_value.valueID = CSSValueContain;
+      m_valueID = CSSValueContain;
       break;
     case ObjectFitCover:
-      m_value.valueID = CSSValueCover;
+      m_valueID = CSSValueCover;
       break;
     case ObjectFitNone:
-      m_value.valueID = CSSValueNone;
+      m_valueID = CSSValueNone;
       break;
     case ObjectFitScaleDown:
-      m_value.valueID = CSSValueScaleDown;
+      m_valueID = CSSValueScaleDown;
       break;
   }
 }
 
 template <>
-inline ObjectFit CSSPrimitiveValue::convertTo() const {
-  switch (m_value.valueID) {
+inline ObjectFit CSSIdentifierValue::convertTo() const {
+  switch (m_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)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(EFillSizeType fillSize)
+    : CSSValue(IdentifierClass) {
   switch (fillSize) {
     case Contain:
-      m_value.valueID = CSSValueContain;
+      m_valueID = CSSValueContain;
       break;
     case Cover:
-      m_value.valueID = CSSValueCover;
+      m_valueID = CSSValueCover;
       break;
     case SizeNone:
-      m_value.valueID = CSSValueNone;
+      m_valueID = CSSValueNone;
       break;
     case SizeLength:
     default:
       ASSERT_NOT_REACHED();
   }
 }
 
 template <>
-inline CSSPrimitiveValue::CSSPrimitiveValue(FontSmoothingMode smoothing)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(FontSmoothingMode smoothing)
+    : CSSValue(IdentifierClass) {
   switch (smoothing) {
     case AutoSmoothing:
-      m_value.valueID = CSSValueAuto;
+      m_valueID = CSSValueAuto;
       return;
     case NoSmoothing:
-      m_value.valueID = CSSValueNone;
+      m_valueID = CSSValueNone;
       return;
     case Antialiased:
-      m_value.valueID = CSSValueAntialiased;
+      m_valueID = CSSValueAntialiased;
       return;
     case SubpixelAntialiased:
-      m_value.valueID = CSSValueSubpixelAntialiased;
+      m_valueID = CSSValueSubpixelAntialiased;
       return;
   }
 
   ASSERT_NOT_REACHED();
-  m_value.valueID = CSSValueAuto;
+  m_valueID = CSSValueAuto;
 }
 
 template <>
-inline FontSmoothingMode CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline FontSmoothingMode CSSIdentifierValue::convertTo() const {
+  switch (m_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)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(FontWeight weight)
+    : CSSValue(IdentifierClass) {
   switch (weight) {
     case FontWeight900:
-      m_value.valueID = CSSValue900;
+      m_valueID = CSSValue900;
       return;
     case FontWeight800:
-      m_value.valueID = CSSValue800;
+      m_valueID = CSSValue800;
       return;
     case FontWeight700:
-      m_value.valueID = CSSValueBold;
+      m_valueID = CSSValueBold;
       return;
     case FontWeight600:
-      m_value.valueID = CSSValue600;
+      m_valueID = CSSValue600;
       return;
     case FontWeight500:
-      m_value.valueID = CSSValue500;
+      m_valueID = CSSValue500;
       return;
     case FontWeight400:
-      m_value.valueID = CSSValueNormal;
+      m_valueID = CSSValueNormal;
       return;
     case FontWeight300:
-      m_value.valueID = CSSValue300;
+      m_valueID = CSSValue300;
       return;
     case FontWeight200:
-      m_value.valueID = CSSValue200;
+      m_valueID = CSSValue200;
       return;
     case FontWeight100:
-      m_value.valueID = CSSValue100;
+      m_valueID = CSSValue100;
       return;
   }
 
   ASSERT_NOT_REACHED();
-  m_value.valueID = CSSValueNormal;
+  m_valueID = CSSValueNormal;
 }
 
 template <>
-inline FontWeight CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline FontWeight CSSIdentifierValue::convertTo() const {
+  switch (m_valueID) {
     case CSSValueBold:
       return FontWeightBold;
     case CSSValueNormal:
       return FontWeightNormal;
     case CSSValue900:
       return FontWeight900;
     case CSSValue800:
       return FontWeight800;
     case CSSValue700:
       return FontWeight700;
@@ skipping 11 matching lines @@
       return FontWeight100;
     default:
       break;
   }
 
   ASSERT_NOT_REACHED();
   return FontWeightNormal;
 }
 
 template <>
-inline CSSPrimitiveValue::CSSPrimitiveValue(FontStyle italic)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(FontStyle italic)
+    : CSSValue(IdentifierClass) {
   switch (italic) {
     case FontStyleNormal:
-      m_value.valueID = CSSValueNormal;
+      m_valueID = CSSValueNormal;
       return;
     case FontStyleOblique:
-      m_value.valueID = CSSValueOblique;
+      m_valueID = CSSValueOblique;
       return;
     case FontStyleItalic:
-      m_value.valueID = CSSValueItalic;
+      m_valueID = CSSValueItalic;
       return;
   }
 
   ASSERT_NOT_REACHED();
-  m_value.valueID = CSSValueNormal;
+  m_valueID = CSSValueNormal;
 }
 
 template <>
-inline FontStyle CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline FontStyle CSSIdentifierValue::convertTo() const {
+  switch (m_valueID) {
     case CSSValueOblique:
       return FontStyleOblique;
     case CSSValueItalic:
       return FontStyleItalic;
     case CSSValueNormal:
       return FontStyleNormal;
     default:
       break;
   }
   ASSERT_NOT_REACHED();
   return FontStyleNormal;
 }
 
 template <>
-inline CSSPrimitiveValue::CSSPrimitiveValue(FontStretch stretch)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(FontStretch stretch)
+    : CSSValue(IdentifierClass) {
   switch (stretch) {
     case FontStretchUltraCondensed:
-      m_value.valueID = CSSValueUltraCondensed;
+      m_valueID = CSSValueUltraCondensed;
       return;
     case FontStretchExtraCondensed:
-      m_value.valueID = CSSValueExtraCondensed;
+      m_valueID = CSSValueExtraCondensed;
       return;
     case FontStretchCondensed:
-      m_value.valueID = CSSValueCondensed;
+      m_valueID = CSSValueCondensed;
       return;
     case FontStretchSemiCondensed:
-      m_value.valueID = CSSValueSemiCondensed;
+      m_valueID = CSSValueSemiCondensed;
       return;
     case FontStretchNormal:
-      m_value.valueID = CSSValueNormal;
+      m_valueID = CSSValueNormal;
       return;
     case FontStretchSemiExpanded:
-      m_value.valueID = CSSValueSemiExpanded;
+      m_valueID = CSSValueSemiExpanded;
       return;
     case FontStretchExpanded:
-      m_value.valueID = CSSValueExpanded;
+      m_valueID = CSSValueExpanded;
       return;
     case FontStretchExtraExpanded:
-      m_value.valueID = CSSValueExtraExpanded;
+      m_valueID = CSSValueExtraExpanded;
       return;
     case FontStretchUltraExpanded:
-      m_value.valueID = CSSValueUltraExpanded;
+      m_valueID = CSSValueUltraExpanded;
       return;
   }
 
   ASSERT_NOT_REACHED();
-  m_value.valueID = CSSValueNormal;
+  m_valueID = CSSValueNormal;
 }
 
 template <>
-inline FontStretch CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline FontStretch CSSIdentifierValue::convertTo() const {
+  switch (m_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(TextRenderingMode e)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(TextRenderingMode e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     case AutoTextRendering:
-      m_value.valueID = CSSValueAuto;
+      m_valueID = CSSValueAuto;
       break;
     case OptimizeSpeed:
-      m_value.valueID = CSSValueOptimizeSpeed;
+      m_valueID = CSSValueOptimizeSpeed;
       break;
     case OptimizeLegibility:
-      m_value.valueID = CSSValueOptimizeLegibility;
+      m_valueID = CSSValueOptimizeLegibility;
       break;
     case GeometricPrecision:
-      m_value.valueID = CSSValueGeometricPrecision;
+      m_valueID = CSSValueGeometricPrecision;
       break;
   }
 }
 
 template <>
-inline TextRenderingMode CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline TextRenderingMode CSSIdentifierValue::convertTo() const {
+  switch (m_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)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(ESpeak e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     case SpeakNone:
-      m_value.valueID = CSSValueNone;
+      m_valueID = CSSValueNone;
       break;
     case SpeakNormal:
-      m_value.valueID = CSSValueNormal;
+      m_valueID = CSSValueNormal;
       break;
     case SpeakSpellOut:
-      m_value.valueID = CSSValueSpellOut;
+      m_valueID = CSSValueSpellOut;
       break;
     case SpeakDigits:
-      m_value.valueID = CSSValueDigits;
+      m_valueID = CSSValueDigits;
       break;
     case SpeakLiteralPunctuation:
-      m_value.valueID = CSSValueLiteralPunctuation;
+      m_valueID = CSSValueLiteralPunctuation;
       break;
     case SpeakNoPunctuation:
-      m_value.valueID = CSSValueNoPunctuation;
+      m_valueID = CSSValueNoPunctuation;
       break;
   }
 }
 
 template <>
-inline Order CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline Order CSSIdentifierValue::convertTo() const {
+  switch (m_valueID) {
     case CSSValueLogical:
       return LogicalOrder;
     case CSSValueVisual:
       return VisualOrder;
     default:
       break;
   }
 
   ASSERT_NOT_REACHED();
   return LogicalOrder;
 }
 
 template <>
-inline CSSPrimitiveValue::CSSPrimitiveValue(Order e)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(Order e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     case LogicalOrder:
-      m_value.valueID = CSSValueLogical;
+      m_valueID = CSSValueLogical;
       break;
     case VisualOrder:
-      m_value.valueID = CSSValueVisual;
+      m_valueID = CSSValueVisual;
       break;
   }
 }
 
 template <>
-inline ESpeak CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline ESpeak CSSIdentifierValue::convertTo() const {
+  switch (m_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)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(WebBlendMode blendMode)
+    : CSSValue(IdentifierClass) {
   switch (blendMode) {
     case WebBlendModeNormal:
-      m_value.valueID = CSSValueNormal;
+      m_valueID = CSSValueNormal;
       break;
     case WebBlendModeMultiply:
-      m_value.valueID = CSSValueMultiply;
+      m_valueID = CSSValueMultiply;
       break;
     case WebBlendModeScreen:
-      m_value.valueID = CSSValueScreen;
+      m_valueID = CSSValueScreen;
       break;
     case WebBlendModeOverlay:
-      m_value.valueID = CSSValueOverlay;
+      m_valueID = CSSValueOverlay;
       break;
     case WebBlendModeDarken:
-      m_value.valueID = CSSValueDarken;
+      m_valueID = CSSValueDarken;
       break;
     case WebBlendModeLighten:
-      m_value.valueID = CSSValueLighten;
+      m_valueID = CSSValueLighten;
       break;
     case WebBlendModeColorDodge:
-      m_value.valueID = CSSValueColorDodge;
+      m_valueID = CSSValueColorDodge;
       break;
     case WebBlendModeColorBurn:
-      m_value.valueID = CSSValueColorBurn;
+      m_valueID = CSSValueColorBurn;
       break;
     case WebBlendModeHardLight:
-      m_value.valueID = CSSValueHardLight;
+      m_valueID = CSSValueHardLight;
       break;
     case WebBlendModeSoftLight:
-      m_value.valueID = CSSValueSoftLight;
+      m_valueID = CSSValueSoftLight;
       break;
     case WebBlendModeDifference:
-      m_value.valueID = CSSValueDifference;
+      m_valueID = CSSValueDifference;
       break;
     case WebBlendModeExclusion:
-      m_value.valueID = CSSValueExclusion;
+      m_valueID = CSSValueExclusion;
       break;
     case WebBlendModeHue:
-      m_value.valueID = CSSValueHue;
+      m_valueID = CSSValueHue;
       break;
     case WebBlendModeSaturation:
-      m_value.valueID = CSSValueSaturation;
+      m_valueID = CSSValueSaturation;
       break;
     case WebBlendModeColor:
-      m_value.valueID = CSSValueColor;
+      m_valueID = CSSValueColor;
       break;
     case WebBlendModeLuminosity:
-      m_value.valueID = CSSValueLuminosity;
+      m_valueID = CSSValueLuminosity;
       break;
   }
 }
 
 template <>
-inline WebBlendMode CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline WebBlendMode CSSIdentifierValue::convertTo() const {
+  switch (m_valueID) {
     case CSSValueNormal:
       return WebBlendModeNormal;
     case CSSValueMultiply:
       return WebBlendModeMultiply;
     case CSSValueScreen:
       return WebBlendModeScreen;
     case CSSValueOverlay:
       return WebBlendModeOverlay;
     case CSSValueDarken:
       return WebBlendModeDarken;
@@ skipping 21 matching lines @@
       return WebBlendModeLuminosity;
     default:
       break;
   }
 
   ASSERT_NOT_REACHED();
   return WebBlendModeNormal;
 }
 
 template <>
-inline CSSPrimitiveValue::CSSPrimitiveValue(LineCap e)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(LineCap e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     case ButtCap:
-      m_value.valueID = CSSValueButt;
+      m_valueID = CSSValueButt;
       break;
     case RoundCap:
-      m_value.valueID = CSSValueRound;
+      m_valueID = CSSValueRound;
       break;
     case SquareCap:
-      m_value.valueID = CSSValueSquare;
+      m_valueID = CSSValueSquare;
       break;
   }
 }
 
 template <>
-inline LineCap CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline LineCap CSSIdentifierValue::convertTo() const {
+  switch (m_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)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(LineJoin e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     case MiterJoin:
-      m_value.valueID = CSSValueMiter;
+      m_valueID = CSSValueMiter;
       break;
     case RoundJoin:
-      m_value.valueID = CSSValueRound;
+      m_valueID = CSSValueRound;
       break;
     case BevelJoin:
-      m_value.valueID = CSSValueBevel;
+      m_valueID = CSSValueBevel;
       break;
   }
 }
 
 template <>
-inline LineJoin CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline LineJoin CSSIdentifierValue::convertTo() const {
+  switch (m_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)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(WindRule e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     case RULE_NONZERO:
-      m_value.valueID = CSSValueNonzero;
+      m_valueID = CSSValueNonzero;
       break;
     case RULE_EVENODD:
-      m_value.valueID = CSSValueEvenodd;
+      m_valueID = CSSValueEvenodd;
       break;
   }
 }
 
 template <>
-inline WindRule CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline WindRule CSSIdentifierValue::convertTo() const {
+  switch (m_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)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(EAlignmentBaseline e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     case AB_AUTO:
-      m_value.valueID = CSSValueAuto;
+      m_valueID = CSSValueAuto;
       break;
     case AB_BASELINE:
-      m_value.valueID = CSSValueBaseline;
+      m_valueID = CSSValueBaseline;
       break;
     case AB_BEFORE_EDGE:
-      m_value.valueID = CSSValueBeforeEdge;
+      m_valueID = CSSValueBeforeEdge;
       break;
     case AB_TEXT_BEFORE_EDGE:
-      m_value.valueID = CSSValueTextBeforeEdge;
+      m_valueID = CSSValueTextBeforeEdge;
       break;
     case AB_MIDDLE:
-      m_value.valueID = CSSValueMiddle;
+      m_valueID = CSSValueMiddle;
       break;
     case AB_CENTRAL:
-      m_value.valueID = CSSValueCentral;
+      m_valueID = CSSValueCentral;
       break;
     case AB_AFTER_EDGE:
-      m_value.valueID = CSSValueAfterEdge;
+      m_valueID = CSSValueAfterEdge;
       break;
     case AB_TEXT_AFTER_EDGE:
-      m_value.valueID = CSSValueTextAfterEdge;
+      m_valueID = CSSValueTextAfterEdge;
       break;
     case AB_IDEOGRAPHIC:
-      m_value.valueID = CSSValueIdeographic;
+      m_valueID = CSSValueIdeographic;
       break;
     case AB_ALPHABETIC:
-      m_value.valueID = CSSValueAlphabetic;
+      m_valueID = CSSValueAlphabetic;
       break;
     case AB_HANGING:
-      m_value.valueID = CSSValueHanging;
+      m_valueID = CSSValueHanging;
       break;
     case AB_MATHEMATICAL:
-      m_value.valueID = CSSValueMathematical;
+      m_valueID = CSSValueMathematical;
       break;
   }
 }
 
 template <>
-inline EAlignmentBaseline CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline EAlignmentBaseline CSSIdentifierValue::convertTo() const {
+  switch (m_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 13 matching lines @@
       return AB_MATHEMATICAL;
     default:
       break;
   }
 
   ASSERT_NOT_REACHED();
   return AB_AUTO;
 }
 
 template <>
-inline CSSPrimitiveValue::CSSPrimitiveValue(EBorderCollapse e)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(EBorderCollapse e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     case BorderCollapseSeparate:
-      m_value.valueID = CSSValueSeparate;
+      m_valueID = CSSValueSeparate;
       break;
     case BorderCollapseCollapse:
-      m_value.valueID = CSSValueCollapse;
+      m_valueID = CSSValueCollapse;
       break;
   }
 }
 
 template <>
-inline EBorderCollapse CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline EBorderCollapse CSSIdentifierValue::convertTo() const {
+  switch (m_valueID) {
     case CSSValueSeparate:
       return BorderCollapseSeparate;
     case CSSValueCollapse:
       return BorderCollapseCollapse;
     default:
       break;
   }
 
   ASSERT_NOT_REACHED();
   return BorderCollapseSeparate;
 }
 
 template <>
-inline CSSPrimitiveValue::CSSPrimitiveValue(EImageRendering e)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(EImageRendering e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     case ImageRenderingAuto:
-      m_value.valueID = CSSValueAuto;
+      m_valueID = CSSValueAuto;
       break;
     case ImageRenderingOptimizeSpeed:
-      m_value.valueID = CSSValueOptimizeSpeed;
+      m_valueID = CSSValueOptimizeSpeed;
       break;
     case ImageRenderingOptimizeQuality:
-      m_value.valueID = CSSValueOptimizeQuality;
+      m_valueID = CSSValueOptimizeQuality;
       break;
     case ImageRenderingPixelated:
-      m_value.valueID = CSSValuePixelated;
+      m_valueID = CSSValuePixelated;
       break;
     case ImageRenderingOptimizeContrast:
-      m_value.valueID = CSSValueWebkitOptimizeContrast;
+      m_valueID = CSSValueWebkitOptimizeContrast;
       break;
   }
 }
 
 template <>
-inline EImageRendering CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline EImageRendering CSSIdentifierValue::convertTo() const {
+  switch (m_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)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(ETransformStyle3D e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     case TransformStyle3DFlat:
-      m_value.valueID = CSSValueFlat;
+      m_valueID = CSSValueFlat;
       break;
     case TransformStyle3DPreserve3D:
-      m_value.valueID = CSSValuePreserve3d;
+      m_valueID = CSSValuePreserve3d;
       break;
   }
 }
 
 template <>
-inline ETransformStyle3D CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline ETransformStyle3D CSSIdentifierValue::convertTo() const {
+  switch (m_valueID) {
     case CSSValueFlat:
       return TransformStyle3DFlat;
     case CSSValuePreserve3d:
       return TransformStyle3DPreserve3D;
     default:
       break;
   }
 
   ASSERT_NOT_REACHED();
   return TransformStyle3DFlat;
 }
 
 template <>
-inline CSSPrimitiveValue::CSSPrimitiveValue(EBufferedRendering e)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(EBufferedRendering e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     case BR_AUTO:
-      m_value.valueID = CSSValueAuto;
+      m_valueID = CSSValueAuto;
       break;
     case BR_DYNAMIC:
-      m_value.valueID = CSSValueDynamic;
+      m_valueID = CSSValueDynamic;
       break;
     case BR_STATIC:
-      m_value.valueID = CSSValueStatic;
+      m_valueID = CSSValueStatic;
       break;
   }
 }
 
 template <>
-inline EBufferedRendering CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline EBufferedRendering CSSIdentifierValue::convertTo() const {
+  switch (m_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)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(EColorInterpolation e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     case CI_AUTO:
-      m_value.valueID = CSSValueAuto;
+      m_valueID = CSSValueAuto;
       break;
     case CI_SRGB:
-      m_value.valueID = CSSValueSRGB;
+      m_valueID = CSSValueSRGB;
       break;
     case CI_LINEARRGB:
-      m_value.valueID = CSSValueLinearRGB;
+      m_valueID = CSSValueLinearRGB;
       break;
   }
 }
 
 template <>
-inline EColorInterpolation CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline EColorInterpolation CSSIdentifierValue::convertTo() const {
+  switch (m_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)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(EColorRendering e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     case CR_AUTO:
-      m_value.valueID = CSSValueAuto;
+      m_valueID = CSSValueAuto;
       break;
     case CR_OPTIMIZESPEED:
-      m_value.valueID = CSSValueOptimizeSpeed;
+      m_valueID = CSSValueOptimizeSpeed;
       break;
     case CR_OPTIMIZEQUALITY:
-      m_value.valueID = CSSValueOptimizeQuality;
+      m_valueID = CSSValueOptimizeQuality;
       break;
   }
 }
 
 template <>
-inline EColorRendering CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline EColorRendering CSSIdentifierValue::convertTo() const {
+  switch (m_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)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(EDominantBaseline e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     case DB_AUTO:
-      m_value.valueID = CSSValueAuto;
+      m_valueID = CSSValueAuto;
       break;
     case DB_USE_SCRIPT:
-      m_value.valueID = CSSValueUseScript;
+      m_valueID = CSSValueUseScript;
       break;
     case DB_NO_CHANGE:
-      m_value.valueID = CSSValueNoChange;
+      m_valueID = CSSValueNoChange;
       break;
     case DB_RESET_SIZE:
-      m_value.valueID = CSSValueResetSize;
+      m_valueID = CSSValueResetSize;
       break;
     case DB_CENTRAL:
-      m_value.valueID = CSSValueCentral;
+      m_valueID = CSSValueCentral;
       break;
     case DB_MIDDLE:
-      m_value.valueID = CSSValueMiddle;
+      m_valueID = CSSValueMiddle;
       break;
     case DB_TEXT_BEFORE_EDGE:
-      m_value.valueID = CSSValueTextBeforeEdge;
+      m_valueID = CSSValueTextBeforeEdge;
       break;
     case DB_TEXT_AFTER_EDGE:
-      m_value.valueID = CSSValueTextAfterEdge;
+      m_valueID = CSSValueTextAfterEdge;
       break;
     case DB_IDEOGRAPHIC:
-      m_value.valueID = CSSValueIdeographic;
+      m_valueID = CSSValueIdeographic;
       break;
     case DB_ALPHABETIC:
-      m_value.valueID = CSSValueAlphabetic;
+      m_valueID = CSSValueAlphabetic;
       break;
     case DB_HANGING:
-      m_value.valueID = CSSValueHanging;
+      m_valueID = CSSValueHanging;
       break;
     case DB_MATHEMATICAL:
-      m_value.valueID = CSSValueMathematical;
+      m_valueID = CSSValueMathematical;
       break;
   }
 }
 
 template <>
-inline EDominantBaseline CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline EDominantBaseline CSSIdentifierValue::convertTo() const {
+  switch (m_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 13 matching lines @@
       return DB_TEXT_BEFORE_EDGE;
     default:
       break;
   }
 
   ASSERT_NOT_REACHED();
   return DB_AUTO;
 }
 
 template <>
-inline CSSPrimitiveValue::CSSPrimitiveValue(EShapeRendering e)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(EShapeRendering e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     case SR_AUTO:
-      m_value.valueID = CSSValueAuto;
+      m_valueID = CSSValueAuto;
       break;
     case SR_OPTIMIZESPEED:
-      m_value.valueID = CSSValueOptimizeSpeed;
+      m_valueID = CSSValueOptimizeSpeed;
       break;
     case SR_CRISPEDGES:
-      m_value.valueID = CSSValueCrispEdges;
+      m_valueID = CSSValueCrispEdges;
       break;
     case SR_GEOMETRICPRECISION:
-      m_value.valueID = CSSValueGeometricPrecision;
+      m_valueID = CSSValueGeometricPrecision;
       break;
   }
 }
 
 template <>
-inline EShapeRendering CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline EShapeRendering CSSIdentifierValue::convertTo() const {
+  switch (m_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)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(ETextAnchor e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     case TA_START:
-      m_value.valueID = CSSValueStart;
+      m_valueID = CSSValueStart;
       break;
     case TA_MIDDLE:
-      m_value.valueID = CSSValueMiddle;
+      m_valueID = CSSValueMiddle;
       break;
     case TA_END:
-      m_value.valueID = CSSValueEnd;
+      m_valueID = CSSValueEnd;
       break;
   }
 }
 
 template <>
-inline ETextAnchor CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline ETextAnchor CSSIdentifierValue::convertTo() const {
+  switch (m_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(EVectorEffect e)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(EVectorEffect e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     case VE_NONE:
-      m_value.valueID = CSSValueNone;
+      m_valueID = CSSValueNone;
       break;
     case VE_NON_SCALING_STROKE:
-      m_value.valueID = CSSValueNonScalingStroke;
+      m_valueID = CSSValueNonScalingStroke;
       break;
   }
 }
 
 template <>
-inline EVectorEffect CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline EVectorEffect CSSIdentifierValue::convertTo() const {
+  switch (m_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) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(EPaintOrderType e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     case PT_FILL:
-      m_value.valueID = CSSValueFill;
+      m_valueID = CSSValueFill;
       break;
     case PT_STROKE:
-      m_value.valueID = CSSValueStroke;
+      m_valueID = CSSValueStroke;
       break;
     case PT_MARKERS:
-      m_value.valueID = CSSValueMarkers;
+      m_valueID = CSSValueMarkers;
       break;
     default:
       ASSERT_NOT_REACHED();
-      m_value.valueID = CSSValueFill;
+      m_valueID = CSSValueFill;
       break;
   }
 }
 
 template <>
-inline EPaintOrderType CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline EPaintOrderType CSSIdentifierValue::convertTo() const {
+  switch (m_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)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(EMaskType e)
+    : CSSValue(IdentifierClass) {
   switch (e) {
     case MT_LUMINANCE:
-      m_value.valueID = CSSValueLuminance;
+      m_valueID = CSSValueLuminance;
       break;
     case MT_ALPHA:
-      m_value.valueID = CSSValueAlpha;
+      m_valueID = CSSValueAlpha;
       break;
   }
 }
 
 template <>
-inline EMaskType CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline EMaskType CSSIdentifierValue::convertTo() const {
+  switch (m_valueID) {
     case CSSValueLuminance:
       return MT_LUMINANCE;
     case CSSValueAlpha:
       return MT_ALPHA;
     default:
       break;
   }
 
   ASSERT_NOT_REACHED();
   return MT_LUMINANCE;
 }
 
 template <>
-inline TouchAction CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline TouchAction CSSIdentifierValue::convertTo() const {
+  switch (m_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 TouchActionManipulation;
     case CSSValuePinchZoom:
       return TouchActionPinchZoom;
     default:
       break;
   }
 
   ASSERT_NOT_REACHED();
   return TouchActionNone;
 }
 
 template <>
-inline CSSPrimitiveValue::CSSPrimitiveValue(EIsolation i)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(EIsolation i)
+    : CSSValue(IdentifierClass) {
   switch (i) {
     case IsolationAuto:
-      m_value.valueID = CSSValueAuto;
+      m_valueID = CSSValueAuto;
       break;
     case IsolationIsolate:
-      m_value.valueID = CSSValueIsolate;
+      m_valueID = CSSValueIsolate;
       break;
   }
 }
 
 template <>
-inline EIsolation CSSPrimitiveValue::convertTo() const {
-  ASSERT(isValueID());
-  switch (m_value.valueID) {
+inline EIsolation CSSIdentifierValue::convertTo() const {
+  switch (m_valueID) {
     case CSSValueAuto:
       return IsolationAuto;
     case CSSValueIsolate:
       return IsolationIsolate;
     default:
       break;
   }
 
   ASSERT_NOT_REACHED();
   return IsolationAuto;
 }
 
 template <>
-inline CSSPrimitiveValue::CSSPrimitiveValue(CSSBoxType cssBox)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(CSSBoxType cssBox)
+    : CSSValue(IdentifierClass) {
   switch (cssBox) {
     case MarginBox:
-      m_value.valueID = CSSValueMarginBox;
+      m_valueID = CSSValueMarginBox;
       break;
     case BorderBox:
-      m_value.valueID = CSSValueBorderBox;
+      m_valueID = CSSValueBorderBox;
       break;
     case PaddingBox:
-      m_value.valueID = CSSValuePaddingBox;
+      m_valueID = CSSValuePaddingBox;
       break;
     case ContentBox:
-      m_value.valueID = CSSValueContentBox;
+      m_valueID = CSSValueContentBox;
       break;
     case BoxMissing:
       // The missing box should convert to a null primitive value.
       ASSERT_NOT_REACHED();
   }
 }
 
 template <>
-inline CSSBoxType CSSPrimitiveValue::convertTo() const {
+inline CSSBoxType CSSIdentifierValue::convertTo() const {
   switch (getValueID()) {
     case CSSValueMarginBox:
       return MarginBox;
     case CSSValueBorderBox:
       return BorderBox;
     case CSSValuePaddingBox:
       return PaddingBox;
     case CSSValueContentBox:
       return ContentBox;
     default:
       break;
   }
   ASSERT_NOT_REACHED();
   return ContentBox;
 }
 
 template <>
-inline CSSPrimitiveValue::CSSPrimitiveValue(ItemPosition itemPosition)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(ItemPosition itemPosition)
+    : CSSValue(IdentifierClass) {
   switch (itemPosition) {
     case ItemPositionAuto:
       // The 'auto' values might have been already resolved.
       NOTREACHED();
-      m_value.valueID = CSSValueNormal;
+      m_valueID = CSSValueNormal;
       break;
     case ItemPositionNormal:
-      m_value.valueID = CSSValueNormal;
+      m_valueID = CSSValueNormal;
       break;
     case ItemPositionStretch:
-      m_value.valueID = CSSValueStretch;
+      m_valueID = CSSValueStretch;
       break;
     case ItemPositionBaseline:
-      m_value.valueID = CSSValueBaseline;
+      m_valueID = CSSValueBaseline;
       break;
     case ItemPositionLastBaseline:
-      m_value.valueID = CSSValueLastBaseline;
+      m_valueID = CSSValueLastBaseline;
       break;
     case ItemPositionCenter:
-      m_value.valueID = CSSValueCenter;
+      m_valueID = CSSValueCenter;
       break;
     case ItemPositionStart:
-      m_value.valueID = CSSValueStart;
+      m_valueID = CSSValueStart;
       break;
     case ItemPositionEnd:
-      m_value.valueID = CSSValueEnd;
+      m_valueID = CSSValueEnd;
       break;
     case ItemPositionSelfStart:
-      m_value.valueID = CSSValueSelfStart;
+      m_valueID = CSSValueSelfStart;
       break;
     case ItemPositionSelfEnd:
-      m_value.valueID = CSSValueSelfEnd;
+      m_valueID = CSSValueSelfEnd;
       break;
     case ItemPositionFlexStart:
-      m_value.valueID = CSSValueFlexStart;
+      m_valueID = CSSValueFlexStart;
       break;
     case ItemPositionFlexEnd:
-      m_value.valueID = CSSValueFlexEnd;
+      m_valueID = CSSValueFlexEnd;
       break;
     case ItemPositionLeft:
-      m_value.valueID = CSSValueLeft;
+      m_valueID = CSSValueLeft;
       break;
     case ItemPositionRight:
-      m_value.valueID = CSSValueRight;
+      m_valueID = CSSValueRight;
       break;
   }
 }
 
 template <>
-inline ItemPosition CSSPrimitiveValue::convertTo() const {
-  switch (m_value.valueID) {
+inline ItemPosition CSSIdentifierValue::convertTo() const {
+  switch (m_valueID) {
     case CSSValueAuto:
       return ItemPositionAuto;
     case CSSValueNormal:
       return ItemPositionNormal;
     case CSSValueStretch:
       return ItemPositionStretch;
     case CSSValueBaseline:
       return ItemPositionBaseline;
     case CSSValueLastBaseline:
       return ItemPositionLastBaseline;
@@ skipping 16 matching lines @@
     case CSSValueRight:
       return ItemPositionRight;
     default:
       break;
   }
   ASSERT_NOT_REACHED();
   return ItemPositionAuto;
 }
 
 template <>
-inline CSSPrimitiveValue::CSSPrimitiveValue(ContentPosition contentPosition)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(ContentPosition contentPosition)
+    : CSSValue(IdentifierClass) {
   switch (contentPosition) {
     case ContentPositionNormal:
-      m_value.valueID = CSSValueNormal;
+      m_valueID = CSSValueNormal;
       break;
     case ContentPositionBaseline:
-      m_value.valueID = CSSValueBaseline;
+      m_valueID = CSSValueBaseline;
       break;
     case ContentPositionLastBaseline:
-      m_value.valueID = CSSValueLastBaseline;
+      m_valueID = CSSValueLastBaseline;
       break;
     case ContentPositionCenter:
-      m_value.valueID = CSSValueCenter;
+      m_valueID = CSSValueCenter;
       break;
     case ContentPositionStart:
-      m_value.valueID = CSSValueStart;
+      m_valueID = CSSValueStart;
       break;
     case ContentPositionEnd:
-      m_value.valueID = CSSValueEnd;
+      m_valueID = CSSValueEnd;
       break;
     case ContentPositionFlexStart:
-      m_value.valueID = CSSValueFlexStart;
+      m_valueID = CSSValueFlexStart;
       break;
     case ContentPositionFlexEnd:
-      m_value.valueID = CSSValueFlexEnd;
+      m_valueID = CSSValueFlexEnd;
       break;
     case ContentPositionLeft:
-      m_value.valueID = CSSValueLeft;
+      m_valueID = CSSValueLeft;
       break;
     case ContentPositionRight:
-      m_value.valueID = CSSValueRight;
+      m_valueID = CSSValueRight;
       break;
   }
 }
 
 template <>
-inline ContentPosition CSSPrimitiveValue::convertTo() const {
-  switch (m_value.valueID) {
+inline ContentPosition CSSIdentifierValue::convertTo() const {
+  switch (m_valueID) {
     case CSSValueNormal:
       return ContentPositionNormal;
     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 ContentPositionNormal;
 }
 
 template <>
-inline CSSPrimitiveValue::CSSPrimitiveValue(
+inline CSSIdentifierValue::CSSIdentifierValue(
     ContentDistributionType contentDistribution)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+    : CSSValue(IdentifierClass) {
   switch (contentDistribution) {
     case ContentDistributionDefault:
-      m_value.valueID = CSSValueDefault;
+      m_valueID = CSSValueDefault;
       break;
     case ContentDistributionSpaceBetween:
-      m_value.valueID = CSSValueSpaceBetween;
+      m_valueID = CSSValueSpaceBetween;
       break;
     case ContentDistributionSpaceAround:
-      m_value.valueID = CSSValueSpaceAround;
+      m_valueID = CSSValueSpaceAround;
       break;
     case ContentDistributionSpaceEvenly:
-      m_value.valueID = CSSValueSpaceEvenly;
+      m_valueID = CSSValueSpaceEvenly;
       break;
     case ContentDistributionStretch:
-      m_value.valueID = CSSValueStretch;
+      m_valueID = CSSValueStretch;
       break;
   }
 }
 
 template <>
-inline ContentDistributionType CSSPrimitiveValue::convertTo() const {
-  switch (m_value.valueID) {
+inline ContentDistributionType CSSIdentifierValue::convertTo() const {
+  switch (m_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)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(
+    OverflowAlignment overflowAlignment)
+    : CSSValue(IdentifierClass) {
   switch (overflowAlignment) {
     case OverflowAlignmentDefault:
-      m_value.valueID = CSSValueDefault;
+      m_valueID = CSSValueDefault;
       break;
     case OverflowAlignmentUnsafe:
-      m_value.valueID = CSSValueUnsafe;
+      m_valueID = CSSValueUnsafe;
       break;
     case OverflowAlignmentSafe:
-      m_value.valueID = CSSValueSafe;
+      m_valueID = CSSValueSafe;
       break;
   }
 }
 
 template <>
-inline OverflowAlignment CSSPrimitiveValue::convertTo() const {
-  switch (m_value.valueID) {
+inline OverflowAlignment CSSIdentifierValue::convertTo() const {
+  switch (m_valueID) {
     case CSSValueUnsafe:
       return OverflowAlignmentUnsafe;
     case CSSValueSafe:
       return OverflowAlignmentSafe;
     default:
       break;
   }
   ASSERT_NOT_REACHED();
   return OverflowAlignmentUnsafe;
 }
 
 template <>
-inline CSSPrimitiveValue::CSSPrimitiveValue(ScrollBehavior behavior)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(ScrollBehavior behavior)
+    : CSSValue(IdentifierClass) {
   switch (behavior) {
     case ScrollBehaviorAuto:
-      m_value.valueID = CSSValueAuto;
+      m_valueID = CSSValueAuto;
       break;
     case ScrollBehaviorSmooth:
-      m_value.valueID = CSSValueSmooth;
+      m_valueID = CSSValueSmooth;
       break;
     case ScrollBehaviorInstant:
       // Behavior 'instant' is only allowed in ScrollOptions arguments passed to
       // CSSOM scroll APIs.
       ASSERT_NOT_REACHED();
   }
 }
 
 template <>
-inline ScrollBehavior CSSPrimitiveValue::convertTo() const {
+inline ScrollBehavior CSSIdentifierValue::convertTo() const {
   switch (getValueID()) {
     case CSSValueAuto:
       return ScrollBehaviorAuto;
     case CSSValueSmooth:
       return ScrollBehaviorSmooth;
     default:
       break;
   }
   ASSERT_NOT_REACHED();
   return ScrollBehaviorAuto;
 }
 
 template <>
-inline CSSPrimitiveValue::CSSPrimitiveValue(ScrollSnapType snapType)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(ScrollSnapType snapType)
+    : CSSValue(IdentifierClass) {
   switch (snapType) {
     case ScrollSnapTypeNone:
-      m_value.valueID = CSSValueNone;
+      m_valueID = CSSValueNone;
       break;
     case ScrollSnapTypeMandatory:
-      m_value.valueID = CSSValueMandatory;
+      m_valueID = CSSValueMandatory;
       break;
     case ScrollSnapTypeProximity:
-      m_value.valueID = CSSValueProximity;
+      m_valueID = CSSValueProximity;
       break;
   }
 }
 
 template <>
-inline ScrollSnapType CSSPrimitiveValue::convertTo() const {
+inline ScrollSnapType CSSIdentifierValue::convertTo() const {
   switch (getValueID()) {
     case CSSValueNone:
       return ScrollSnapTypeNone;
     case CSSValueMandatory:
       return ScrollSnapTypeMandatory;
     case CSSValueProximity:
       return ScrollSnapTypeProximity;
     default:
       break;
   }
   ASSERT_NOT_REACHED();
   return ScrollSnapTypeNone;
 }
 
 template <>
-inline CSSPrimitiveValue::CSSPrimitiveValue(Containment snapType)
-    : CSSValue(PrimitiveClass) {
-  init(UnitType::ValueID);
+inline CSSIdentifierValue::CSSIdentifierValue(Containment snapType)
+    : CSSValue(IdentifierClass) {
   switch (snapType) {
     case ContainsNone:
-      m_value.valueID = CSSValueNone;
+      m_valueID = CSSValueNone;
       break;
     case ContainsStrict:
-      m_value.valueID = CSSValueStrict;
+      m_valueID = CSSValueStrict;
       break;
     case ContainsContent:
-      m_value.valueID = CSSValueContent;
+      m_valueID = CSSValueContent;
       break;
     case ContainsPaint:
-      m_value.valueID = CSSValuePaint;
+      m_valueID = CSSValuePaint;
       break;
     case ContainsStyle:
-      m_value.valueID = CSSValueStyle;
+      m_valueID = CSSValueStyle;
       break;
     case ContainsLayout:
-      m_value.valueID = CSSValueLayout;
+      m_valueID = CSSValueLayout;
       break;
     case ContainsSize:
-      m_value.valueID = CSSValueSize;
+      m_valueID = CSSValueSize;
       break;
   }
 }
 
 template <>
-inline Containment CSSPrimitiveValue::convertTo() const {
+inline Containment CSSIdentifierValue::convertTo() const {
   switch (getValueID()) {
     case CSSValueNone:
       return ContainsNone;
     case CSSValueStrict:
       return ContainsStrict;
     case CSSValueContent:
       return ContainsContent;
     case CSSValuePaint:
       return ContainsPaint;
     case CSSValueStyle:
       return ContainsStyle;
     case CSSValueLayout:
       return ContainsLayout;
     case CSSValueSize:
       return ContainsSize;
     default:
       break;
   }
   ASSERT_NOT_REACHED();
   return ContainsNone;
 }
 
 }  // namespace blink
 
 #endif