Remove all ordering requirements in CSSValueKeywords.in (WIP)

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
@@ skipping 38 matching lines @@
 #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 a separate file, and generate them.
+template <typename T>
+inline CSSValueID platformEnumToCSSValueID(T);
+template <typename T>
+inline T CSSValueIDToPlatformEnum(CSSValueID);
+
 // 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());
@@ skipping 185 matching lines @@
       m_valueID = CSSValueSolid;
       break;
     case BorderStyleDouble:
       m_valueID = CSSValueDouble;
       break;
   }
 }
 
 template <>
 inline EBorderStyle CSSIdentifierValue::convertTo() const {
-  if (m_valueID == CSSValueAuto)  // Valid for CSS outline-style
-    return BorderStyleDotted;
-  return (EBorderStyle)(m_valueID - CSSValueNone);
+  switch (m_valueID) {
+    case CSSValueNone:
+      return BorderStyleNone;
+    case CSSValueHidden:
+      return BorderStyleHidden;
+    case CSSValueInset:
+      return BorderStyleInset;
+    case CSSValueGroove:
+      return BorderStyleGroove;
+    case CSSValueOutset:
+      return BorderStyleOutset;
+    case CSSValueRidge:
+      return BorderStyleRidge;
+    case CSSValueDotted:
+    case CSSValueAuto:
+      return BorderStyleDotted;
+    case CSSValueDashed:
+      return BorderStyleDashed;
+    case CSSValueSolid:
+      return BorderStyleSolid;
+    case CSSValueDouble:
+      return BorderStyleDouble;
+    default:
+      break;
+  }
+
+  NOTREACHED();
+  return BorderStyleNone;
 }
 
 template <>
 inline OutlineIsAuto CSSIdentifierValue::convertTo() const {
   if (m_valueID == CSSValueAuto)
     return OutlineIsAutoOn;
   return OutlineIsAutoOff;
 }
 
 template <>
@@ skipping 232 matching lines @@
       m_valueID = CSSValueTextarea;
       break;
     case CapsLockIndicatorPart:
       m_valueID = CSSValueCapsLockIndicator;
       break;
   }
 }
 
 template <>
 inline ControlPart CSSIdentifierValue::convertTo() const {
-  if (m_valueID == CSSValueNone)
-    return NoControlPart;
-  return ControlPart(m_valueID - CSSValueCheckbox + 1);
+  switch (m_valueID) {
+    case CSSValueNone:
+      return NoControlPart;
+    case CSSValueCheckbox:
+      return CheckboxPart;
+    case CSSValueRadio:
+      return RadioPart;
+    case CSSValuePushButton:
+      return PushButtonPart;
+    case CSSValueSquareButton:
+      return SquareButtonPart;
+    case CSSValueButton:
+      return ButtonPart;
+    case CSSValueButtonBevel:
+      return ButtonBevelPart;
+    case CSSValueInnerSpinButton:
+      return InnerSpinButtonPart;
+    case CSSValueListbox:
+      return ListboxPart;
+    case CSSValueListitem:
+      return ListItemPart;
+    case CSSValueMediaEnterFullscreenButton:
+      return MediaEnterFullscreenButtonPart;
+    case CSSValueMediaExitFullscreenButton:
+      return MediaExitFullscreenButtonPart;
+    case CSSValueMediaFullscreenVolumeSlider:
+      return MediaFullscreenVolumeSliderPart;
+    case CSSValueMediaFullscreenVolumeSliderThumb:
+      return MediaFullscreenVolumeSliderThumbPart;
+    case CSSValueMediaMuteButton:
+      return MediaMuteButtonPart;
+    case CSSValueMediaPlayButton:
+      return MediaPlayButtonPart;
+    case CSSValueMediaOverlayPlayButton:
+      return MediaOverlayPlayButtonPart;
+    case CSSValueMediaToggleClosedCaptionsButton:
+      return MediaToggleClosedCaptionsButtonPart;
+    case CSSValueMediaSlider:
+      return MediaSliderPart;
+    case CSSValueMediaSliderthumb:
+      return MediaSliderThumbPart;
+    case CSSValueMediaVolumeSliderContainer:
+      return MediaVolumeSliderContainerPart;
+    case CSSValueMediaVolumeSlider:
+      return MediaVolumeSliderPart;
+    case CSSValueMediaVolumeSliderthumb:
+      return MediaVolumeSliderThumbPart;
+    case CSSValueMediaControlsBackground:
+      return MediaControlsBackgroundPart;
+    case CSSValueMediaControlsFullscreenBackground:
+      return MediaControlsFullscreenBackgroundPart;
+    case CSSValueMediaCurrentTimeDisplay:
+      return MediaCurrentTimePart;
+    case CSSValueMediaTimeRemainingDisplay:
+      return MediaTimeRemainingPart;
+    case CSSValueInternalMediaCastOffButton:
+      return MediaCastOffButtonPart;
+    case CSSValueInternalMediaOverlayCastOffButton:
+      return MediaOverlayCastOffButtonPart;
+    case CSSValueInternalMediaTrackSelectionCheckmark:
+      return MediaTrackSelectionCheckmarkPart;
+    case CSSValueInternalMediaClosedCaptionsIcon:
+      return MediaClosedCaptionsIconPart;
+    case CSSValueInternalMediaSubtitlesIcon:
+      return MediaSubtitlesIconPart;
+    case CSSValueInternalMediaOverflowButton:
+      return MediaOverflowMenuButtonPart;
+    case CSSValueInternalMediaDownloadButton:
+      return MediaDownloadIconPart;
+    case CSSValueMenulist:
+      return MenulistPart;
+    case CSSValueMenulistButton:
+      return MenulistButtonPart;
+    case CSSValueMenulistText:
+      return MenulistTextPart;
+    case CSSValueMenulistTextfield:
+      return MenulistTextFieldPart;
+    case CSSValueMeter:
+      return MeterPart;
+    case CSSValueProgressBar:
+      return ProgressBarPart;
+    case CSSValueProgressBarValue:
+      return ProgressBarValuePart;
+    case CSSValueSliderHorizontal:
+      return SliderHorizontalPart;
+    case CSSValueSliderVertical:
+      return SliderVerticalPart;
+    case CSSValueSliderthumbHorizontal:
+      return SliderThumbHorizontalPart;
+    case CSSValueSliderthumbVertical:
+      return SliderThumbVerticalPart;
+    case CSSValueCaret:
+      return CaretPart;
+    case CSSValueSearchfield:
+      return SearchFieldPart;
+    case CSSValueSearchfieldCancelButton:
+      return SearchFieldCancelButtonPart;
+    case CSSValueTextfield:
+      return TextFieldPart;
+    case CSSValueTextarea:
+      return TextAreaPart;
+    case CSSValueCapsLockIndicator:
+      return CapsLockIndicatorPart;
+    default:
+      break;
+  }
+
+  NOTREACHED();
+  return NoControlPart;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(EBackfaceVisibility e)
     : CSSValue(IdentifierClass) {
   switch (e) {
     case BackfaceVisibilityVisible:
       m_valueID = CSSValueVisible;
       break;
     case BackfaceVisibilityHidden:
@@ skipping 577 matching lines @@
       break;
     case CURSOR_WEBKIT_GRABBING:
       m_valueID = CSSValueWebkitGrabbing;
       break;
   }
 }
 
 template <>
 inline ECursor CSSIdentifierValue::convertTo() const {
   switch (m_valueID) {
+    case CSSValueAuto:
+      return CURSOR_AUTO;
+    case CSSValueCrosshair:
+      return CURSOR_CROSS;
+    case CSSValueDefault:
+      return CURSOR_DEFAULT;
+    case CSSValuePointer:
+      return CURSOR_POINTER;
+    case CSSValueMove:
+      return CURSOR_MOVE;
+    case CSSValueVerticalText:
+      return CURSOR_VERTICAL_TEXT;
+    case CSSValueCell:
+      return CURSOR_CELL;
+    case CSSValueContextMenu:
+      return CURSOR_CONTEXT_MENU;
+    case CSSValueAlias:
+      return CURSOR_ALIAS;
+    case CSSValueProgress:
+      return CURSOR_PROGRESS;
+    case CSSValueNoDrop:
+      return CURSOR_NO_DROP;
+    case CSSValueNotAllowed:
+      return CURSOR_NOT_ALLOWED;
+    case CSSValueZoomIn:
+    case CSSValueWebkitZoomIn:
+      return CURSOR_ZOOM_IN;
+    case CSSValueZoomOut:
+    case CSSValueWebkitZoomOut:
+      return CURSOR_ZOOM_OUT;
+    case CSSValueEResize:
+      return CURSOR_E_RESIZE;
+    case CSSValueNeResize:
+      return CURSOR_NE_RESIZE;
+    case CSSValueNwResize:
+      return CURSOR_NW_RESIZE;
+    case CSSValueNResize:
+      return CURSOR_N_RESIZE;
+    case CSSValueSeResize:
+      return CURSOR_SE_RESIZE;
+    case CSSValueSwResize:
+      return CURSOR_SW_RESIZE;
+    case CSSValueSResize:
+      return CURSOR_S_RESIZE;
+    case CSSValueWResize:
+      return CURSOR_W_RESIZE;
+    case CSSValueEwResize:
+      return CURSOR_EW_RESIZE;
+    case CSSValueNsResize:
+      return CURSOR_NS_RESIZE;
+    case CSSValueNeswResize:
+      return CURSOR_NESW_RESIZE;
+    case CSSValueNwseResize:
+      return CURSOR_NWSE_RESIZE;
+    case CSSValueColResize:
+      return CURSOR_COL_RESIZE;
+    case CSSValueRowResize:
+      return CURSOR_ROW_RESIZE;
+    case CSSValueText:
+      return CURSOR_TEXT;
+    case CSSValueWait:
+      return CURSOR_WAIT;
+    case CSSValueHelp:
+      return CURSOR_HELP;
+    case CSSValueAllScroll:
+      return CURSOR_ALL_SCROLL;
+    case CSSValueWebkitGrab:
+      return CURSOR_WEBKIT_GRAB;
+    case CSSValueWebkitGrabbing:
+      return CURSOR_WEBKIT_GRABBING;
     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_valueID - CSSValueAuto);
+      break;
   }
+
+  NOTREACHED();
+  return CURSOR_AUTO;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(EDisplay e)
     : CSSValue(IdentifierClass) {
   switch (e) {
     case EDisplay::Inline:
       m_valueID = CSSValueInline;
       break;
     case EDisplay::Block:
@@ skipping 57 matching lines @@
       m_valueID = CSSValueContents;
       break;
     case EDisplay::None:
       m_valueID = CSSValueNone;
       break;
   }
 }
 
 template <>
 inline EDisplay CSSIdentifierValue::convertTo() const {
-  if (m_valueID == CSSValueNone)
-    return EDisplay::None;
+  switch (m_valueID) {
+    case CSSValueInline:
+      return EDisplay::Inline;
+    case CSSValueBlock:
+      return EDisplay::Block;
+    case CSSValueListItem:
+      return EDisplay::ListItem;
+    case CSSValueInlineBlock:
+      return EDisplay::InlineBlock;
+    case CSSValueTable:
+      return EDisplay::Table;
+    case CSSValueInlineTable:
+      return EDisplay::InlineTable;
+    case CSSValueTableRowGroup:
+      return EDisplay::TableRowGroup;
+    case CSSValueTableHeaderGroup:
+      return EDisplay::TableHeaderGroup;
+    case CSSValueTableFooterGroup:
+      return EDisplay::TableFooterGroup;
+    case CSSValueTableRow:
+      return EDisplay::TableRow;
+    case CSSValueTableColumnGroup:
+      return EDisplay::TableColumnGroup;
+    case CSSValueTableColumn:
+      return EDisplay::TableColumn;
+    case CSSValueTableCell:
+      return EDisplay::TableCell;
+    case CSSValueTableCaption:
+      return EDisplay::TableCaption;
+    case CSSValueWebkitBox:
+      return EDisplay::Box;
+    case CSSValueWebkitInlineBox:
+      return EDisplay::InlineBox;
+    case CSSValueFlex:
+    case CSSValueWebkitFlex:
+      return EDisplay::Flex;
+    case CSSValueInlineFlex:
+    case CSSValueWebkitInlineFlex:
+      return EDisplay::InlineFlex;
+    case CSSValueGrid:
+      return EDisplay::Grid;
+    case CSSValueInlineGrid:
+      return EDisplay::InlineGrid;
+    case CSSValueNone:
+      return EDisplay::None;
+    default:
+      break;
+  }
 
-  if (m_valueID == CSSValueWebkitFlex)
-    return EDisplay::Flex;
-  if (m_valueID == CSSValueWebkitInlineFlex)
-    return EDisplay::InlineFlex;
-
-  EDisplay display = static_cast<EDisplay>(m_valueID - CSSValueInline);
-  // TODO(sashab): Check display is a valid EDisplay here.
-  return display;
+  NOTREACHED();
+  return EDisplay::Inline;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(EEmptyCells e)
     : CSSValue(IdentifierClass) {
   switch (e) {
     case EEmptyCells::Show:
       m_valueID = CSSValueShow;
       break;
     case EEmptyCells::Hide:
@@ skipping 219 matching lines @@
       return EListStylePosition::Inside;
     default:
       break;
   }
 
   ASSERT_NOT_REACHED();
   return EListStylePosition::Outside;
 }
 
 template <>
-inline CSSIdentifierValue::CSSIdentifierValue(EListStyleType e)
-    : CSSValue(IdentifierClass) {
+inline CSSValueID platformEnumToCSSValueID(EListStyleType e) {
   switch (e) {
     case ArabicIndic:
-      m_valueID = CSSValueArabicIndic;
-      break;
+      return CSSValueArabicIndic;
     case Armenian:
-      m_valueID = CSSValueArmenian;
-      break;
+      return CSSValueArmenian;
     case Bengali:
-      m_valueID = CSSValueBengali;
-      break;
+      return CSSValueBengali;
     case Cambodian:
-      m_valueID = CSSValueCambodian;
-      break;
+      return CSSValueCambodian;
     case Circle:
-      m_valueID = CSSValueCircle;
-      break;
+      return CSSValueCircle;
     case CjkEarthlyBranch:
-      m_valueID = CSSValueCjkEarthlyBranch;
-      break;
+      return CSSValueCjkEarthlyBranch;
     case CjkHeavenlyStem:
-      m_valueID = CSSValueCjkHeavenlyStem;
-      break;
+      return CSSValueCjkHeavenlyStem;
     case CJKIdeographic:
-      m_valueID = CSSValueCjkIdeographic;
-      break;
+      return CSSValueCjkIdeographic;
     case DecimalLeadingZero:
-      m_valueID = CSSValueDecimalLeadingZero;
-      break;
+      return CSSValueDecimalLeadingZero;
     case DecimalListStyle:
-      m_valueID = CSSValueDecimal;
-      break;
+      return CSSValueDecimal;
     case Devanagari:
-      m_valueID = CSSValueDevanagari;
-      break;
+      return CSSValueDevanagari;
     case Disc:
-      m_valueID = CSSValueDisc;
-      break;
+      return CSSValueDisc;
     case EthiopicHalehame:
-      m_valueID = CSSValueEthiopicHalehame;
-      break;
+      return CSSValueEthiopicHalehame;
     case EthiopicHalehameAm:
-      m_valueID = CSSValueEthiopicHalehameAm;
-      break;
+      return CSSValueEthiopicHalehameAm;
     case EthiopicHalehameTiEt:
-      m_valueID = CSSValueEthiopicHalehameTiEt;
-      break;
+      return CSSValueEthiopicHalehameTiEt;
     case EthiopicHalehameTiEr:
-      m_valueID = CSSValueEthiopicHalehameTiEr;
-      break;
+      return CSSValueEthiopicHalehameTiEr;
     case Georgian:
-      m_valueID = CSSValueGeorgian;
-      break;
+      return CSSValueGeorgian;
     case Gujarati:
-      m_valueID = CSSValueGujarati;
-      break;
+      return CSSValueGujarati;
     case Gurmukhi:
-      m_valueID = CSSValueGurmukhi;
-      break;
+      return CSSValueGurmukhi;
     case Hangul:
-      m_valueID = CSSValueHangul;
-      break;
+      return CSSValueHangul;
     case HangulConsonant:
-      m_valueID = CSSValueHangulConsonant;
-      break;
+      return CSSValueHangulConsonant;
     case KoreanHangulFormal:
-      m_valueID = CSSValueKoreanHangulFormal;
-      break;
+      return CSSValueKoreanHangulFormal;
     case KoreanHanjaFormal:
-      m_valueID = CSSValueKoreanHanjaFormal;
-      break;
+      return CSSValueKoreanHanjaFormal;
     case KoreanHanjaInformal:
-      m_valueID = CSSValueKoreanHanjaInformal;
-      break;
+      return CSSValueKoreanHanjaInformal;
     case Hebrew:
-      m_valueID = CSSValueHebrew;
-      break;
+      return CSSValueHebrew;
     case Hiragana:
-      m_valueID = CSSValueHiragana;
-      break;
+      return CSSValueHiragana;
     case HiraganaIroha:
-      m_valueID = CSSValueHiraganaIroha;
-      break;
+      return CSSValueHiraganaIroha;
     case Kannada:
-      m_valueID = CSSValueKannada;
-      break;
+      return CSSValueKannada;
     case Katakana:
-      m_valueID = CSSValueKatakana;
-      break;
+      return CSSValueKatakana;
     case KatakanaIroha:
-      m_valueID = CSSValueKatakanaIroha;
-      break;
+      return CSSValueKatakanaIroha;
     case Khmer:
-      m_valueID = CSSValueKhmer;
-      break;
+      return CSSValueKhmer;
     case Lao:
-      m_valueID = CSSValueLao;
-      break;
+      return CSSValueLao;
     case LowerAlpha:
-      m_valueID = CSSValueLowerAlpha;
-      break;
+      return CSSValueLowerAlpha;
     case LowerArmenian:
-      m_valueID = CSSValueLowerArmenian;
-      break;
+      return CSSValueLowerArmenian;
     case LowerGreek:
-      m_valueID = CSSValueLowerGreek;
-      break;
+      return CSSValueLowerGreek;
     case LowerLatin:
-      m_valueID = CSSValueLowerLatin;
-      break;
+      return CSSValueLowerLatin;
     case LowerRoman:
-      m_valueID = CSSValueLowerRoman;
-      break;
+      return CSSValueLowerRoman;
     case Malayalam:
-      m_valueID = CSSValueMalayalam;
-      break;
+      return CSSValueMalayalam;
     case Mongolian:
-      m_valueID = CSSValueMongolian;
-      break;
+      return CSSValueMongolian;
     case Myanmar:
-      m_valueID = CSSValueMyanmar;
-      break;
+      return CSSValueMyanmar;
     case NoneListStyle:
-      m_valueID = CSSValueNone;
-      break;
+      return CSSValueNone;
     case Oriya:
-      m_valueID = CSSValueOriya;
-      break;
+      return CSSValueOriya;
     case Persian:
-      m_valueID = CSSValuePersian;
-      break;
+      return CSSValuePersian;
     case SimpChineseFormal:
-      m_valueID = CSSValueSimpChineseFormal;
-      break;
+      return CSSValueSimpChineseFormal;
     case SimpChineseInformal:
-      m_valueID = CSSValueSimpChineseInformal;
-      break;
+      return CSSValueSimpChineseInformal;
     case Square:
-      m_valueID = CSSValueSquare;
-      break;
+      return CSSValueSquare;
     case Telugu:
-      m_valueID = CSSValueTelugu;
-      break;
+      return CSSValueTelugu;
     case Thai:
-      m_valueID = CSSValueThai;
-      break;
+      return CSSValueThai;
     case Tibetan:
-      m_valueID = CSSValueTibetan;
-      break;
+      return CSSValueTibetan;
     case TradChineseFormal:
-      m_valueID = CSSValueTradChineseFormal;
-      break;
+      return CSSValueTradChineseFormal;
     case TradChineseInformal:
-      m_valueID = CSSValueTradChineseInformal;
-      break;
+      return CSSValueTradChineseInformal;
     case UpperAlpha:
-      m_valueID = CSSValueUpperAlpha;
-      break;
+      return CSSValueUpperAlpha;
     case UpperArmenian:
-      m_valueID = CSSValueUpperArmenian;
-      break;
+      return CSSValueUpperArmenian;
     case UpperLatin:
-      m_valueID = CSSValueUpperLatin;
-      break;
+      return CSSValueUpperLatin;
     case UpperRoman:
-      m_valueID = CSSValueUpperRoman;
-      break;
+      return CSSValueUpperRoman;
     case Urdu:
-      m_valueID = CSSValueUrdu;
-      break;
+      return CSSValueUrdu;
   }
-}
-
-template <>
-inline EListStyleType CSSIdentifierValue::convertTo() const {
-  switch (m_valueID) {
+  NOTREACHED();
+  return CSSValueNone;
+}
+
+template <>
+inline EListStyleType CSSValueIDToPlatformEnum(CSSValueID id) {
+  switch (id) {
+    case CSSValueDisc:
+      return Disc;
+    case CSSValueCircle:
+      return Circle;
+    case CSSValueSquare:
+      return Square;
+    case CSSValueDecimal:
+      return DecimalListStyle;
+    case CSSValueDecimalLeadingZero:
+      return DecimalLeadingZero;
+    case CSSValueArabicIndic:
+      return ArabicIndic;
+    case CSSValueBengali:
+      return Bengali;
+    case CSSValueCambodian:
+      return Cambodian;
+    case CSSValueKhmer:
+      return Khmer;
+    case CSSValueDevanagari:
+      return Devanagari;
+    case CSSValueGujarati:
+      return Gujarati;
+    case CSSValueGurmukhi:
+      return Gurmukhi;
+    case CSSValueKannada:
+      return Kannada;
+    case CSSValueLao:
+      return Lao;
+    case CSSValueMalayalam:
+      return Malayalam;
+    case CSSValueMongolian:
+      return Mongolian;
+    case CSSValueMyanmar:
+      return Myanmar;
+    case CSSValueOriya:
+      return Oriya;
+    case CSSValuePersian:
+      return Persian;
+    case CSSValueUrdu:
+      return Urdu;
+    case CSSValueTelugu:
+      return Telugu;
+    case CSSValueTibetan:
+      return Tibetan;
+    case CSSValueThai:
+      return Thai;
+    case CSSValueLowerRoman:
+      return LowerRoman;
+    case CSSValueUpperRoman:
+      return UpperRoman;
+    case CSSValueLowerGreek:
+      return LowerGreek;
+    case CSSValueLowerAlpha:
+      return LowerAlpha;
+    case CSSValueLowerLatin:
+      return LowerLatin;
+    case CSSValueUpperAlpha:
+      return UpperAlpha;
+    case CSSValueUpperLatin:
+      return UpperLatin;
+    case CSSValueCjkEarthlyBranch:
+      return CjkEarthlyBranch;
+    case CSSValueCjkHeavenlyStem:
+      return CjkHeavenlyStem;
+    case CSSValueEthiopicHalehame:
+      return EthiopicHalehame;
+    case CSSValueEthiopicHalehameAm:
+      return EthiopicHalehameAm;
+    case CSSValueEthiopicHalehameTiEr:
+      return EthiopicHalehameTiEr;
+    case CSSValueEthiopicHalehameTiEt:
+      return EthiopicHalehameTiEt;
+    case CSSValueHangul:
+      return Hangul;
+    case CSSValueHangulConsonant:
+      return HangulConsonant;
+    case CSSValueKoreanHangulFormal:
+      return KoreanHangulFormal;
+    case CSSValueKoreanHanjaFormal:
+      return KoreanHanjaFormal;
+    case CSSValueKoreanHanjaInformal:
+      return KoreanHanjaInformal;
+    case CSSValueHebrew:
+      return Hebrew;
+    case CSSValueArmenian:
+      return Armenian;
+    case CSSValueLowerArmenian:
+      return LowerArmenian;
+    case CSSValueUpperArmenian:
+      return UpperArmenian;
+    case CSSValueGeorgian:
+      return Georgian;
+    case CSSValueCjkIdeographic:
+      return CJKIdeographic;
+    case CSSValueSimpChineseFormal:
+      return SimpChineseFormal;
+    case CSSValueSimpChineseInformal:
+      return SimpChineseInformal;
+    case CSSValueTradChineseFormal:
+      return TradChineseFormal;
+    case CSSValueTradChineseInformal:
+      return TradChineseInformal;
+    case CSSValueHiragana:
+      return Hiragana;
+    case CSSValueKatakana:
+      return Katakana;
+    case CSSValueHiraganaIroha:
+      return HiraganaIroha;
+    case CSSValueKatakanaIroha:
+      return KatakanaIroha;
     case CSSValueNone:
       return NoneListStyle;
     default:
-      return static_cast<EListStyleType>(m_valueID - CSSValueDisc);
+      break;
   }
-}
-
-template <>
+
+  NOTREACHED();
+  return NoneListStyle;
+}
+
+template <>
+inline CSSIdentifierValue::CSSIdentifierValue(EListStyleType e)
+    : CSSValue(IdentifierClass) {
+  m_valueID = platformEnumToCSSValueID(e);
+}
+
+template <>
+inline EListStyleType CSSIdentifierValue::convertTo() const {
+  return CSSValueIDToPlatformEnum<EListStyleType>(m_valueID);
+}
+
+template <>
 inline CSSIdentifierValue::CSSIdentifierValue(EMarginCollapse e)
     : CSSValue(IdentifierClass) {
   switch (e) {
     case MarginCollapseCollapse:
       m_valueID = CSSValueCollapse;
       break;
     case MarginCollapseSeparate:
       m_valueID = CSSValueSeparate;
       break;
     case MarginCollapseDiscard:
@@ skipping 287 matching lines @@
       break;
     case WEBKIT_CENTER:
       m_valueID = CSSValueWebkitCenter;
       break;
   }
 }
 
 template <>
 inline ETextAlign CSSIdentifierValue::convertTo() const {
   switch (m_valueID) {
+    case CSSValueLeft:
+      return LEFT;
+    case CSSValueRight:
+      return RIGHT;
+    case CSSValueCenter:
+    case CSSValueInternalCenter:
+      return CENTER;
+    case CSSValueJustify:
+      return JUSTIFY;
+    case CSSValueWebkitLeft:
+      return WEBKIT_LEFT;
+    case CSSValueWebkitRight:
+      return WEBKIT_RIGHT;
+    case CSSValueWebkitCenter:
+      return WEBKIT_CENTER;
     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_valueID - CSSValueLeft);
+      break;
   }
+
+  NOTREACHED();
+  return LEFT;
 }
 
 template <>
 inline CSSIdentifierValue::CSSIdentifierValue(TextAlignLast e)
     : CSSValue(IdentifierClass) {
   switch (e) {
     case TextAlignLastStart:
       m_valueID = CSSValueStart;
       break;
     case TextAlignLastEnd:
@@ skipping 2581 matching lines @@
     default:
       break;
   }
   ASSERT_NOT_REACHED();
   return ContainsNone;
 }
 
 }  // namespace blink
 
 #endif