review.tizen.org Git - platform/framework/web/crosswalk-tizen.git/blob

   1 /*
   2  * Copyright (C) 2007 Alexey Proskuryakov <ap@nypop.com>.
   3  * Copyright (C) 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
   4  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved.
   5  * (http://www.torchmobile.com/)
   6  * Copyright (C) 2009 Jeff Schiller <codedread@gmail.com>
   7  * Copyright (C) Research In Motion Limited 2010. All rights reserved.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  *
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  20  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  21  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  22  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  23  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  24  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  28  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29  */
  30
  31 #ifndef CSSPrimitiveValueMappings_h
  32 #define CSSPrimitiveValueMappings_h
  33
  34 #include "core/CSSValueKeywords.h"
  35 #include "core/css/CSSCalculationValue.h"
  36 #include "core/css/CSSIdentifierValue.h"
  37 #include "core/css/CSSPrimitiveValue.h"
  38 #include "core/css/CSSReflectionDirection.h"
  39 #include "core/css/CSSToLengthConversionData.h"
  40 #include "core/style/ComputedStyleConstants.h"
  41 #include "core/style/LineClampValue.h"
  42 #include "core/style/SVGComputedStyleDefs.h"
  43 #include "platform/Length.h"
  44 #include "platform/ThemeTypes.h"
  45 #include "platform/fonts/FontDescription.h"
  46 #include "platform/fonts/FontSmoothingMode.h"
  47 #include "platform/fonts/TextRenderingMode.h"
  48 #include "platform/graphics/GraphicsTypes.h"
  49 #include "platform/scroll/ScrollableArea.h"
  50 #include "platform/text/TextDirection.h"
  51 #include "platform/text/TextRun.h"
  52 #include "platform/text/UnicodeBidi.h"
  53 #include "platform/text/WritingMode.h"
  54 #include "public/platform/WebBlendMode.h"
  55 #include "wtf/MathExtras.h"
  56
  57 namespace blink {
  58
  59 // TODO(sashab): Move these to CSSPrimitiveValue.h.
  60 template <>
  61 inline short CSSPrimitiveValue::convertTo() const {
  62   ASSERT(isNumber());
  63   return clampTo<short>(getDoubleValue());
  64 }
  65
  66 template <>
  67 inline unsigned short CSSPrimitiveValue::convertTo() const {
  68   ASSERT(isNumber());
  69   return clampTo<unsigned short>(getDoubleValue());
  70 }
  71
  72 template <>
  73 inline int CSSPrimitiveValue::convertTo() const {
  74   ASSERT(isNumber());
  75   return clampTo<int>(getDoubleValue());
  76 }
  77
  78 template <>
  79 inline unsigned CSSPrimitiveValue::convertTo() const {
  80   ASSERT(isNumber());
  81   return clampTo<unsigned>(getDoubleValue());
  82 }
  83
  84 template <>
  85 inline float CSSPrimitiveValue::convertTo() const {
  86   ASSERT(isNumber());
  87   return clampTo<float>(getDoubleValue());
  88 }
  89
  90 template <>
  91 inline CSSPrimitiveValue::CSSPrimitiveValue(LineClampValue i)
  92     : CSSValue(PrimitiveClass) {
  93   init(i.isPercentage() ? UnitType::Percentage : UnitType::Integer);
  94   m_value.num = static_cast<double>(i.value());
  95 }
  96
  97 template <>
  98 inline LineClampValue CSSPrimitiveValue::convertTo() const {
  99   if (type() == UnitType::Integer)
 100     return LineClampValue(clampTo<int>(m_value.num), LineClampLineCount);
 101
 102   if (type() == UnitType::Percentage)
 103     return LineClampValue(clampTo<int>(m_value.num), LineClampPercentage);
 104
 105   ASSERT_NOT_REACHED();
 106   return LineClampValue();
 107 }
 108
 109 // TODO(sashab): Move these to CSSIdentifierValueMappings.h, and update to use
 110 // the CSSValuePool.
 111 template <>
 112 inline CSSIdentifierValue::CSSIdentifierValue(CSSReflectionDirection e)
 113     : CSSValue(IdentifierClass) {
 114   switch (e) {
 115     case ReflectionAbove:
 116       m_valueID = CSSValueAbove;
 117       break;
 118     case ReflectionBelow:
 119       m_valueID = CSSValueBelow;
 120       break;
 121     case ReflectionLeft:
 122       m_valueID = CSSValueLeft;
 123       break;
 124     case ReflectionRight:
 125       m_valueID = CSSValueRight;
 126   }
 127 }
 128
 129 template <>
 130 inline CSSReflectionDirection CSSIdentifierValue::convertTo() const {
 131   switch (m_valueID) {
 132     case CSSValueAbove:
 133       return ReflectionAbove;
 134     case CSSValueBelow:
 135       return ReflectionBelow;
 136     case CSSValueLeft:
 137       return ReflectionLeft;
 138     case CSSValueRight:
 139       return ReflectionRight;
 140     default:
 141       break;
 142   }
 143
 144   ASSERT_NOT_REACHED();
 145   return ReflectionBelow;
 146 }
 147
 148 template <>
 149 inline CSSIdentifierValue::CSSIdentifierValue(ColumnFill columnFill)
 150     : CSSValue(IdentifierClass) {
 151   switch (columnFill) {
 152     case ColumnFillAuto:
 153       m_valueID = CSSValueAuto;
 154       break;
 155     case ColumnFillBalance:
 156       m_valueID = CSSValueBalance;
 157       break;
 158   }
 159 }
 160
 161 template <>
 162 inline ColumnFill CSSIdentifierValue::convertTo() const {
 163   if (m_valueID == CSSValueBalance)
 164     return ColumnFillBalance;
 165   if (m_valueID == CSSValueAuto)
 166     return ColumnFillAuto;
 167   ASSERT_NOT_REACHED();
 168   return ColumnFillBalance;
 169 }
 170
 171 template <>
 172 inline CSSIdentifierValue::CSSIdentifierValue(ColumnSpan columnSpan)
 173     : CSSValue(IdentifierClass) {
 174   switch (columnSpan) {
 175     case ColumnSpanAll:
 176       m_valueID = CSSValueAll;
 177       break;
 178     case ColumnSpanNone:
 179       m_valueID = CSSValueNone;
 180       break;
 181   }
 182 }
 183
 184 template <>
 185 inline ColumnSpan CSSIdentifierValue::convertTo() const {
 186   switch (m_valueID) {
 187     case CSSValueAll:
 188       return ColumnSpanAll;
 189     default:
 190       ASSERT_NOT_REACHED();
 191     // fall-through
 192     case CSSValueNone:
 193       return ColumnSpanNone;
 194   }
 195 }
 196
 197 template <>
 198 inline CSSIdentifierValue::CSSIdentifierValue(PrintColorAdjust value)
 199     : CSSValue(IdentifierClass) {
 200   switch (value) {
 201     case PrintColorAdjustExact:
 202       m_valueID = CSSValueExact;
 203       break;
 204     case PrintColorAdjustEconomy:
 205       m_valueID = CSSValueEconomy;
 206       break;
 207   }
 208 }
 209
 210 template <>
 211 inline PrintColorAdjust CSSIdentifierValue::convertTo() const {
 212   switch (m_valueID) {
 213     case CSSValueEconomy:
 214       return PrintColorAdjustEconomy;
 215     case CSSValueExact:
 216       return PrintColorAdjustExact;
 217     default:
 218       break;
 219   }
 220
 221   ASSERT_NOT_REACHED();
 222   return PrintColorAdjustEconomy;
 223 }
 224
 225 template <>
 226 inline CSSIdentifierValue::CSSIdentifierValue(EBorderStyle e)
 227     : CSSValue(IdentifierClass) {
 228   switch (e) {
 229     case BorderStyleNone:
 230       m_valueID = CSSValueNone;
 231       break;
 232     case BorderStyleHidden:
 233       m_valueID = CSSValueHidden;
 234       break;
 235     case BorderStyleInset:
 236       m_valueID = CSSValueInset;
 237       break;
 238     case BorderStyleGroove:
 239       m_valueID = CSSValueGroove;
 240       break;
 241     case BorderStyleRidge:
 242       m_valueID = CSSValueRidge;
 243       break;
 244     case BorderStyleOutset:
 245       m_valueID = CSSValueOutset;
 246       break;
 247     case BorderStyleDotted:
 248       m_valueID = CSSValueDotted;
 249       break;
 250     case BorderStyleDashed:
 251       m_valueID = CSSValueDashed;
 252       break;
 253     case BorderStyleSolid:
 254       m_valueID = CSSValueSolid;
 255       break;
 256     case BorderStyleDouble:
 257       m_valueID = CSSValueDouble;
 258       break;
 259   }
 260 }
 261
 262 template <>
 263 inline EBorderStyle CSSIdentifierValue::convertTo() const {
 264   if (m_valueID == CSSValueAuto)  // Valid for CSS outline-style
 265     return BorderStyleDotted;
 266   return (EBorderStyle)(m_valueID - CSSValueNone);
 267 }
 268
 269 template <>
 270 inline OutlineIsAuto CSSIdentifierValue::convertTo() const {
 271   if (m_valueID == CSSValueAuto)
 272     return OutlineIsAutoOn;
 273   return OutlineIsAutoOff;
 274 }
 275
 276 template <>
 277 inline CSSIdentifierValue::CSSIdentifierValue(CompositeOperator e)
 278     : CSSValue(IdentifierClass) {
 279   switch (e) {
 280     case CompositeClear:
 281       m_valueID = CSSValueClear;
 282       break;
 283     case CompositeCopy:
 284       m_valueID = CSSValueCopy;
 285       break;
 286     case CompositeSourceOver:
 287       m_valueID = CSSValueSourceOver;
 288       break;
 289     case CompositeSourceIn:
 290       m_valueID = CSSValueSourceIn;
 291       break;
 292     case CompositeSourceOut:
 293       m_valueID = CSSValueSourceOut;
 294       break;
 295     case CompositeSourceAtop:
 296       m_valueID = CSSValueSourceAtop;
 297       break;
 298     case CompositeDestinationOver:
 299       m_valueID = CSSValueDestinationOver;
 300       break;
 301     case CompositeDestinationIn:
 302       m_valueID = CSSValueDestinationIn;
 303       break;
 304     case CompositeDestinationOut:
 305       m_valueID = CSSValueDestinationOut;
 306       break;
 307     case CompositeDestinationAtop:
 308       m_valueID = CSSValueDestinationAtop;
 309       break;
 310     case CompositeXOR:
 311       m_valueID = CSSValueXor;
 312       break;
 313     case CompositePlusLighter:
 314       m_valueID = CSSValuePlusLighter;
 315       break;
 316     default:
 317       ASSERT_NOT_REACHED();
 318       break;
 319   }
 320 }
 321
 322 template <>
 323 inline CompositeOperator CSSIdentifierValue::convertTo() const {
 324   switch (m_valueID) {
 325     case CSSValueClear:
 326       return CompositeClear;
 327     case CSSValueCopy:
 328       return CompositeCopy;
 329     case CSSValueSourceOver:
 330       return CompositeSourceOver;
 331     case CSSValueSourceIn:
 332       return CompositeSourceIn;
 333     case CSSValueSourceOut:
 334       return CompositeSourceOut;
 335     case CSSValueSourceAtop:
 336       return CompositeSourceAtop;
 337     case CSSValueDestinationOver:
 338       return CompositeDestinationOver;
 339     case CSSValueDestinationIn:
 340       return CompositeDestinationIn;
 341     case CSSValueDestinationOut:
 342       return CompositeDestinationOut;
 343     case CSSValueDestinationAtop:
 344       return CompositeDestinationAtop;
 345     case CSSValueXor:
 346       return CompositeXOR;
 347     case CSSValuePlusLighter:
 348       return CompositePlusLighter;
 349     default:
 350       break;
 351   }
 352
 353   ASSERT_NOT_REACHED();
 354   return CompositeClear;
 355 }
 356
 357 template <>
 358 inline CSSIdentifierValue::CSSIdentifierValue(ControlPart e)
 359     : CSSValue(IdentifierClass) {
 360   switch (e) {
 361     case NoControlPart:
 362       m_valueID = CSSValueNone;
 363       break;
 364     case CheckboxPart:
 365       m_valueID = CSSValueCheckbox;
 366       break;
 367     case RadioPart:
 368       m_valueID = CSSValueRadio;
 369       break;
 370     case PushButtonPart:
 371       m_valueID = CSSValuePushButton;
 372       break;
 373     case SquareButtonPart:
 374       m_valueID = CSSValueSquareButton;
 375       break;
 376     case ButtonPart:
 377       m_valueID = CSSValueButton;
 378       break;
 379     case ButtonBevelPart:
 380       m_valueID = CSSValueButtonBevel;
 381       break;
 382     case InnerSpinButtonPart:
 383       m_valueID = CSSValueInnerSpinButton;
 384       break;
 385     case ListboxPart:
 386       m_valueID = CSSValueListbox;
 387       break;
 388     case ListItemPart:
 389       m_valueID = CSSValueListitem;
 390       break;
 391     case MediaEnterFullscreenButtonPart:
 392       m_valueID = CSSValueMediaEnterFullscreenButton;
 393       break;
 394     case MediaExitFullscreenButtonPart:
 395       m_valueID = CSSValueMediaExitFullscreenButton;
 396       break;
 397     case MediaPlayButtonPart:
 398       m_valueID = CSSValueMediaPlayButton;
 399       break;
 400     case MediaOverlayPlayButtonPart:
 401       m_valueID = CSSValueMediaOverlayPlayButton;
 402       break;
 403 #if defined(OS_TIZEN)
 404     case MediaSeekBackButtonPart:
 405       m_valueID = CSSValueMediaSeekBackButton;
 406       break;
 407     case MediaSeekForwardButtonPart:
 408       m_valueID = CSSValueMediaSeekForwardButton;
 409       break;
 410 #endif
 411     case MediaRotateButtonPart:
 412       m_valueID = CSSValueMediaRotateButton;
 413       break;
 414     case MediaOverlaySpinnerPart:
 415       m_valueID = CSSValueMediaOverlaySpinner;
 416       break;
 417     case MediaMuteButtonPart:
 418       m_valueID = CSSValueMediaMuteButton;
 419       break;
 420     case MediaToggleClosedCaptionsButtonPart:
 421       m_valueID = CSSValueMediaToggleClosedCaptionsButton;
 422       break;
 423     case MediaCastOffButtonPart:
 424       m_valueID = CSSValueInternalMediaCastOffButton;
 425       break;
 426     case MediaOverlayCastOffButtonPart:
 427       m_valueID = CSSValueInternalMediaOverlayCastOffButton;
 428       break;
 429     case MediaSliderPart:
 430       m_valueID = CSSValueMediaSlider;
 431       break;
 432     case MediaSliderThumbPart:
 433       m_valueID = CSSValueMediaSliderthumb;
 434       break;
 435     case MediaVolumeSliderContainerPart:
 436       m_valueID = CSSValueMediaVolumeSliderContainer;
 437       break;
 438     case MediaVolumeSliderPart:
 439       m_valueID = CSSValueMediaVolumeSlider;
 440       break;
 441     case MediaVolumeSliderThumbPart:
 442       m_valueID = CSSValueMediaVolumeSliderthumb;
 443       break;
 444     case MediaControlsBackgroundPart:
 445       m_valueID = CSSValueMediaControlsBackground;
 446       break;
 447     case MediaControlsFullscreenBackgroundPart:
 448       m_valueID = CSSValueMediaControlsFullscreenBackground;
 449       break;
 450     case MediaFullscreenVolumeSliderPart:
 451       m_valueID = CSSValueMediaFullscreenVolumeSlider;
 452       break;
 453     case MediaFullscreenVolumeSliderThumbPart:
 454       m_valueID = CSSValueMediaFullscreenVolumeSliderThumb;
 455       break;
 456     case MediaCurrentTimePart:
 457       m_valueID = CSSValueMediaCurrentTimeDisplay;
 458       break;
 459     case MediaTimeRemainingPart:
 460       m_valueID = CSSValueMediaTimeRemainingDisplay;
 461       break;
 462     case MediaTrackSelectionCheckmarkPart:
 463       m_valueID = CSSValueInternalMediaTrackSelectionCheckmark;
 464       break;
 465     case MediaClosedCaptionsIconPart:
 466       m_valueID = CSSValueInternalMediaClosedCaptionsIcon;
 467       break;
 468     case MediaSubtitlesIconPart:
 469       m_valueID = CSSValueInternalMediaSubtitlesIcon;
 470       break;
 471     case MediaOverflowMenuButtonPart:
 472       m_valueID = CSSValueInternalMediaOverflowButton;
 473       break;
 474     case MediaDownloadIconPart:
 475       m_valueID = CSSValueInternalMediaDownloadButton;
 476       break;
 477     case MenulistPart:
 478       m_valueID = CSSValueMenulist;
 479       break;
 480     case MenulistButtonPart:
 481       m_valueID = CSSValueMenulistButton;
 482       break;
 483     case MenulistTextPart:
 484       m_valueID = CSSValueMenulistText;
 485       break;
 486     case MenulistTextFieldPart:
 487       m_valueID = CSSValueMenulistTextfield;
 488       break;
 489     case MeterPart:
 490       m_valueID = CSSValueMeter;
 491       break;
 492     case ProgressBarPart:
 493       m_valueID = CSSValueProgressBar;
 494       break;
 495     case ProgressBarValuePart:
 496       m_valueID = CSSValueProgressBarValue;
 497       break;
 498     case SliderHorizontalPart:
 499       m_valueID = CSSValueSliderHorizontal;
 500       break;
 501     case SliderVerticalPart:
 502       m_valueID = CSSValueSliderVertical;
 503       break;
 504     case SliderThumbHorizontalPart:
 505       m_valueID = CSSValueSliderthumbHorizontal;
 506       break;
 507     case SliderThumbVerticalPart:
 508       m_valueID = CSSValueSliderthumbVertical;
 509       break;
 510     case CaretPart:
 511       m_valueID = CSSValueCaret;
 512       break;
 513     case SearchFieldPart:
 514       m_valueID = CSSValueSearchfield;
 515       break;
 516     case SearchFieldCancelButtonPart:
 517       m_valueID = CSSValueSearchfieldCancelButton;
 518       break;
 519     case TextFieldPart:
 520       m_valueID = CSSValueTextfield;
 521       break;
 522     case TextAreaPart:
 523       m_valueID = CSSValueTextarea;
 524       break;
 525     case CapsLockIndicatorPart:
 526       m_valueID = CSSValueCapsLockIndicator;
 527       break;
 528   }
 529 }
 530
 531 template <>
 532 inline ControlPart CSSIdentifierValue::convertTo() const {
 533   if (m_valueID == CSSValueNone)
 534     return NoControlPart;
 535   return ControlPart(m_valueID - CSSValueCheckbox + 1);
 536 }
 537
 538 template <>
 539 inline CSSIdentifierValue::CSSIdentifierValue(EBackfaceVisibility e)
 540     : CSSValue(IdentifierClass) {
 541   switch (e) {
 542     case BackfaceVisibilityVisible:
 543       m_valueID = CSSValueVisible;
 544       break;
 545     case BackfaceVisibilityHidden:
 546       m_valueID = CSSValueHidden;
 547       break;
 548   }
 549 }
 550
 551 template <>
 552 inline EBackfaceVisibility CSSIdentifierValue::convertTo() const {
 553   switch (m_valueID) {
 554     case CSSValueVisible:
 555       return BackfaceVisibilityVisible;
 556     case CSSValueHidden:
 557       return BackfaceVisibilityHidden;
 558     default:
 559       break;
 560   }
 561
 562   ASSERT_NOT_REACHED();
 563   return BackfaceVisibilityHidden;
 564 }
 565
 566 template <>
 567 inline CSSIdentifierValue::CSSIdentifierValue(EFillAttachment e)
 568     : CSSValue(IdentifierClass) {
 569   switch (e) {
 570     case ScrollBackgroundAttachment:
 571       m_valueID = CSSValueScroll;
 572       break;
 573     case LocalBackgroundAttachment:
 574       m_valueID = CSSValueLocal;
 575       break;
 576     case FixedBackgroundAttachment:
 577       m_valueID = CSSValueFixed;
 578       break;
 579   }
 580 }
 581
 582 template <>
 583 inline EFillAttachment CSSIdentifierValue::convertTo() const {
 584   switch (m_valueID) {
 585     case CSSValueScroll:
 586       return ScrollBackgroundAttachment;
 587     case CSSValueLocal:
 588       return LocalBackgroundAttachment;
 589     case CSSValueFixed:
 590       return FixedBackgroundAttachment;
 591     default:
 592       break;
 593   }
 594
 595   ASSERT_NOT_REACHED();
 596   return ScrollBackgroundAttachment;
 597 }
 598
 599 template <>
 600 inline CSSIdentifierValue::CSSIdentifierValue(EFillBox e)
 601     : CSSValue(IdentifierClass) {
 602   switch (e) {
 603     case BorderFillBox:
 604       m_valueID = CSSValueBorderBox;
 605       break;
 606     case PaddingFillBox:
 607       m_valueID = CSSValuePaddingBox;
 608       break;
 609     case ContentFillBox:
 610       m_valueID = CSSValueContentBox;
 611       break;
 612     case TextFillBox:
 613       m_valueID = CSSValueText;
 614       break;
 615   }
 616 }
 617
 618 template <>
 619 inline EFillBox CSSIdentifierValue::convertTo() const {
 620   switch (m_valueID) {
 621     case CSSValueBorder:
 622     case CSSValueBorderBox:
 623       return BorderFillBox;
 624     case CSSValuePadding:
 625     case CSSValuePaddingBox:
 626       return PaddingFillBox;
 627     case CSSValueContent:
 628     case CSSValueContentBox:
 629       return ContentFillBox;
 630     case CSSValueText:
 631       return TextFillBox;
 632     default:
 633       break;
 634   }
 635
 636   ASSERT_NOT_REACHED();
 637   return BorderFillBox;
 638 }
 639
 640 template <>
 641 inline CSSIdentifierValue::CSSIdentifierValue(EFillRepeat e)
 642     : CSSValue(IdentifierClass) {
 643   switch (e) {
 644     case RepeatFill:
 645       m_valueID = CSSValueRepeat;
 646       break;
 647     case NoRepeatFill:
 648       m_valueID = CSSValueNoRepeat;
 649       break;
 650     case RoundFill:
 651       m_valueID = CSSValueRound;
 652       break;
 653     case SpaceFill:
 654       m_valueID = CSSValueSpace;
 655       break;
 656   }
 657 }
 658
 659 template <>
 660 inline EFillRepeat CSSIdentifierValue::convertTo() const {
 661   switch (m_valueID) {
 662     case CSSValueRepeat:
 663       return RepeatFill;
 664     case CSSValueNoRepeat:
 665       return NoRepeatFill;
 666     case CSSValueRound:
 667       return RoundFill;
 668     case CSSValueSpace:
 669       return SpaceFill;
 670     default:
 671       break;
 672   }
 673
 674   ASSERT_NOT_REACHED();
 675   return RepeatFill;
 676 }
 677
 678 template <>
 679 inline CSSIdentifierValue::CSSIdentifierValue(EBoxPack e)
 680     : CSSValue(IdentifierClass) {
 681   switch (e) {
 682     case BoxPackStart:
 683       m_valueID = CSSValueStart;
 684       break;
 685     case BoxPackCenter:
 686       m_valueID = CSSValueCenter;
 687       break;
 688     case BoxPackEnd:
 689       m_valueID = CSSValueEnd;
 690       break;
 691     case BoxPackJustify:
 692       m_valueID = CSSValueJustify;
 693       break;
 694   }
 695 }
 696
 697 template <>
 698 inline EBoxPack CSSIdentifierValue::convertTo() const {
 699   switch (m_valueID) {
 700     case CSSValueStart:
 701       return BoxPackStart;
 702     case CSSValueEnd:
 703       return BoxPackEnd;
 704     case CSSValueCenter:
 705       return BoxPackCenter;
 706     case CSSValueJustify:
 707       return BoxPackJustify;
 708     default:
 709       break;
 710   }
 711
 712   ASSERT_NOT_REACHED();
 713   return BoxPackJustify;
 714 }
 715
 716 template <>
 717 inline CSSIdentifierValue::CSSIdentifierValue(EBoxAlignment e)
 718     : CSSValue(IdentifierClass) {
 719   switch (e) {
 720     case BSTRETCH:
 721       m_valueID = CSSValueStretch;
 722       break;
 723     case BSTART:
 724       m_valueID = CSSValueStart;
 725       break;
 726     case BCENTER:
 727       m_valueID = CSSValueCenter;
 728       break;
 729     case BEND:
 730       m_valueID = CSSValueEnd;
 731       break;
 732     case BBASELINE:
 733       m_valueID = CSSValueBaseline;
 734       break;
 735   }
 736 }
 737
 738 template <>
 739 inline EBoxAlignment CSSIdentifierValue::convertTo() const {
 740   switch (m_valueID) {
 741     case CSSValueStretch:
 742       return BSTRETCH;
 743     case CSSValueStart:
 744       return BSTART;
 745     case CSSValueEnd:
 746       return BEND;
 747     case CSSValueCenter:
 748       return BCENTER;
 749     case CSSValueBaseline:
 750       return BBASELINE;
 751     default:
 752       break;
 753   }
 754
 755   ASSERT_NOT_REACHED();
 756   return BSTRETCH;
 757 }
 758
 759 template <>
 760 inline CSSIdentifierValue::CSSIdentifierValue(EBoxDecorationBreak e)
 761     : CSSValue(IdentifierClass) {
 762   switch (e) {
 763     case BoxDecorationBreakSlice:
 764       m_valueID = CSSValueSlice;
 765       break;
 766     case BoxDecorationBreakClone:
 767       m_valueID = CSSValueClone;
 768       break;
 769   }
 770 }
 771
 772 template <>
 773 inline EBoxDecorationBreak CSSIdentifierValue::convertTo() const {
 774   switch (m_valueID) {
 775     case CSSValueSlice:
 776       return BoxDecorationBreakSlice;
 777     case CSSValueClone:
 778       return BoxDecorationBreakClone;
 779     default:
 780       break;
 781   }
 782
 783   ASSERT_NOT_REACHED();
 784   return BoxDecorationBreakSlice;
 785 }
 786
 787 template <>
 788 inline CSSIdentifierValue::CSSIdentifierValue(BackgroundEdgeOrigin e)
 789     : CSSValue(IdentifierClass) {
 790   switch (e) {
 791     case TopEdge:
 792       m_valueID = CSSValueTop;
 793       break;
 794     case RightEdge:
 795       m_valueID = CSSValueRight;
 796       break;
 797     case BottomEdge:
 798       m_valueID = CSSValueBottom;
 799       break;
 800     case LeftEdge:
 801       m_valueID = CSSValueLeft;
 802       break;
 803   }
 804 }
 805
 806 template <>
 807 inline BackgroundEdgeOrigin CSSIdentifierValue::convertTo() const {
 808   switch (m_valueID) {
 809     case CSSValueTop:
 810       return TopEdge;
 811     case CSSValueRight:
 812       return RightEdge;
 813     case CSSValueBottom:
 814       return BottomEdge;
 815     case CSSValueLeft:
 816       return LeftEdge;
 817     default:
 818       break;
 819   }
 820
 821   ASSERT_NOT_REACHED();
 822   return TopEdge;
 823 }
 824
 825 template <>
 826 inline CSSIdentifierValue::CSSIdentifierValue(EBoxSizing e)
 827     : CSSValue(IdentifierClass) {
 828   switch (e) {
 829     case BoxSizingBorderBox:
 830       m_valueID = CSSValueBorderBox;
 831       break;
 832     case BoxSizingContentBox:
 833       m_valueID = CSSValueContentBox;
 834       break;
 835   }
 836 }
 837
 838 template <>
 839 inline EBoxSizing CSSIdentifierValue::convertTo() const {
 840   switch (m_valueID) {
 841     case CSSValueBorderBox:
 842       return BoxSizingBorderBox;
 843     case CSSValueContentBox:
 844       return BoxSizingContentBox;
 845     default:
 846       break;
 847   }
 848
 849   ASSERT_NOT_REACHED();
 850   return BoxSizingBorderBox;
 851 }
 852
 853 template <>
 854 inline CSSIdentifierValue::CSSIdentifierValue(EBoxDirection e)
 855     : CSSValue(IdentifierClass) {
 856   switch (e) {
 857     case BNORMAL:
 858       m_valueID = CSSValueNormal;
 859       break;
 860     case BREVERSE:
 861       m_valueID = CSSValueReverse;
 862       break;
 863   }
 864 }
 865
 866 template <>
 867 inline EBoxDirection CSSIdentifierValue::convertTo() const {
 868   switch (m_valueID) {
 869     case CSSValueNormal:
 870       return BNORMAL;
 871     case CSSValueReverse:
 872       return BREVERSE;
 873     default:
 874       break;
 875   }
 876
 877   ASSERT_NOT_REACHED();
 878   return BNORMAL;
 879 }
 880
 881 template <>
 882 inline CSSIdentifierValue::CSSIdentifierValue(EBoxLines e)
 883     : CSSValue(IdentifierClass) {
 884   switch (e) {
 885     case SINGLE:
 886       m_valueID = CSSValueSingle;
 887       break;
 888     case MULTIPLE:
 889       m_valueID = CSSValueMultiple;
 890       break;
 891   }
 892 }
 893
 894 template <>
 895 inline EBoxLines CSSIdentifierValue::convertTo() const {
 896   switch (m_valueID) {
 897     case CSSValueSingle:
 898       return SINGLE;
 899     case CSSValueMultiple:
 900       return MULTIPLE;
 901     default:
 902       break;
 903   }
 904
 905   ASSERT_NOT_REACHED();
 906   return SINGLE;
 907 }
 908
 909 template <>
 910 inline CSSIdentifierValue::CSSIdentifierValue(EBoxOrient e)
 911     : CSSValue(IdentifierClass) {
 912   switch (e) {
 913     case HORIZONTAL:
 914       m_valueID = CSSValueHorizontal;
 915       break;
 916     case VERTICAL:
 917       m_valueID = CSSValueVertical;
 918       break;
 919   }
 920 }
 921
 922 template <>
 923 inline EBoxOrient CSSIdentifierValue::convertTo() const {
 924   switch (m_valueID) {
 925     case CSSValueHorizontal:
 926     case CSSValueInlineAxis:
 927       return HORIZONTAL;
 928     case CSSValueVertical:
 929     case CSSValueBlockAxis:
 930       return VERTICAL;
 931     default:
 932       break;
 933   }
 934
 935   ASSERT_NOT_REACHED();
 936   return HORIZONTAL;
 937 }
 938
 939 template <>
 940 inline CSSIdentifierValue::CSSIdentifierValue(ECaptionSide e)
 941     : CSSValue(IdentifierClass) {
 942   switch (e) {
 943     case ECaptionSide::Left:
 944       m_valueID = CSSValueLeft;
 945       break;
 946     case ECaptionSide::Right:
 947       m_valueID = CSSValueRight;
 948       break;
 949     case ECaptionSide::Top:
 950       m_valueID = CSSValueTop;
 951       break;
 952     case ECaptionSide::Bottom:
 953       m_valueID = CSSValueBottom;
 954       break;
 955   }
 956 }
 957
 958 template <>
 959 inline ECaptionSide CSSIdentifierValue::convertTo() const {
 960   switch (m_valueID) {
 961     case CSSValueLeft:
 962       return ECaptionSide::Left;
 963     case CSSValueRight:
 964       return ECaptionSide::Right;
 965     case CSSValueTop:
 966       return ECaptionSide::Top;
 967     case CSSValueBottom:
 968       return ECaptionSide::Bottom;
 969     default:
 970       break;
 971   }
 972
 973   ASSERT_NOT_REACHED();
 974   return ECaptionSide::Top;
 975 }
 976
 977 template <>
 978 inline CSSIdentifierValue::CSSIdentifierValue(EClear e)
 979     : CSSValue(IdentifierClass) {
 980   switch (e) {
 981     case ClearNone:
 982       m_valueID = CSSValueNone;
 983       break;
 984     case ClearLeft:
 985       m_valueID = CSSValueLeft;
 986       break;
 987     case ClearRight:
 988       m_valueID = CSSValueRight;
 989       break;
 990     case ClearBoth:
 991       m_valueID = CSSValueBoth;
 992       break;
 993   }
 994 }
 995
 996 template <>
 997 inline EClear CSSIdentifierValue::convertTo() const {
 998   switch (m_valueID) {
 999     case CSSValueNone:
1000       return ClearNone;
1001     case CSSValueLeft:
1002       return ClearLeft;
1003     case CSSValueRight:
1004       return ClearRight;
1005     case CSSValueBoth:
1006       return ClearBoth;
1007     default:
1008       break;
1009   }
1010
1011   ASSERT_NOT_REACHED();
1012   return ClearNone;
1013 }
1014
1015 template <>
1016 inline CSSIdentifierValue::CSSIdentifierValue(ECursor e)
1017     : CSSValue(IdentifierClass) {
1018   switch (e) {
1019     case ECursor::Auto:
1020       m_valueID = CSSValueAuto;
1021       break;
1022     case ECursor::Cross:
1023       m_valueID = CSSValueCrosshair;
1024       break;
1025     case ECursor::Default:
1026       m_valueID = CSSValueDefault;
1027       break;
1028     case ECursor::Pointer:
1029       m_valueID = CSSValuePointer;
1030       break;
1031     case ECursor::Move:
1032       m_valueID = CSSValueMove;
1033       break;
1034     case ECursor::Cell:
1035       m_valueID = CSSValueCell;
1036       break;
1037     case ECursor::VerticalText:
1038       m_valueID = CSSValueVerticalText;
1039       break;
1040     case ECursor::ContextMenu:
1041       m_valueID = CSSValueContextMenu;
1042       break;
1043     case ECursor::Alias:
1044       m_valueID = CSSValueAlias;
1045       break;
1046     case ECursor::Copy:
1047       m_valueID = CSSValueCopy;
1048       break;
1049     case ECursor::None:
1050       m_valueID = CSSValueNone;
1051       break;
1052     case ECursor::Progress:
1053       m_valueID = CSSValueProgress;
1054       break;
1055     case ECursor::NoDrop:
1056       m_valueID = CSSValueNoDrop;
1057       break;
1058     case ECursor::NotAllowed:
1059       m_valueID = CSSValueNotAllowed;
1060       break;
1061     case ECursor::ZoomIn:
1062       m_valueID = CSSValueZoomIn;
1063       break;
1064     case ECursor::ZoomOut:
1065       m_valueID = CSSValueZoomOut;
1066       break;
1067     case ECursor::EResize:
1068       m_valueID = CSSValueEResize;
1069       break;
1070     case ECursor::NeResize:
1071       m_valueID = CSSValueNeResize;
1072       break;
1073     case ECursor::NwResize:
1074       m_valueID = CSSValueNwResize;
1075       break;
1076     case ECursor::NResize:
1077       m_valueID = CSSValueNResize;
1078       break;
1079     case ECursor::SeResize:
1080       m_valueID = CSSValueSeResize;
1081       break;
1082     case ECursor::SwResize:
1083       m_valueID = CSSValueSwResize;
1084       break;
1085     case ECursor::SResize:
1086       m_valueID = CSSValueSResize;
1087       break;
1088     case ECursor::WResize:
1089       m_valueID = CSSValueWResize;
1090       break;
1091     case ECursor::EwResize:
1092       m_valueID = CSSValueEwResize;
1093       break;
1094     case ECursor::NsResize:
1095       m_valueID = CSSValueNsResize;
1096       break;
1097     case ECursor::NeswResize:
1098       m_valueID = CSSValueNeswResize;
1099       break;
1100     case ECursor::NwseResize:
1101       m_valueID = CSSValueNwseResize;
1102       break;
1103     case ECursor::ColResize:
1104       m_valueID = CSSValueColResize;
1105       break;
1106     case ECursor::RowResize:
1107       m_valueID = CSSValueRowResize;
1108       break;
1109     case ECursor::Text:
1110       m_valueID = CSSValueText;
1111       break;
1112     case ECursor::Wait:
1113       m_valueID = CSSValueWait;
1114       break;
1115     case ECursor::Help:
1116       m_valueID = CSSValueHelp;
1117       break;
1118     case ECursor::AllScroll:
1119       m_valueID = CSSValueAllScroll;
1120       break;
1121     case ECursor::WebkitGrab:
1122       m_valueID = CSSValueWebkitGrab;
1123       break;
1124     case ECursor::WebkitGrabbing:
1125       m_valueID = CSSValueWebkitGrabbing;
1126       break;
1127   }
1128 }
1129
1130 template <>
1131 inline ECursor CSSIdentifierValue::convertTo() const {
1132   switch (m_valueID) {
1133     case CSSValueCopy:
1134       return ECursor::Copy;
1135     case CSSValueWebkitZoomIn:
1136       return ECursor::ZoomIn;
1137     case CSSValueWebkitZoomOut:
1138       return ECursor::ZoomOut;
1139     case CSSValueNone:
1140       return ECursor::None;
1141     default:
1142       return static_cast<ECursor>(m_valueID - CSSValueAuto);
1143   }
1144 }
1145
1146 template <>
1147 inline CSSIdentifierValue::CSSIdentifierValue(EDisplay e)
1148     : CSSValue(IdentifierClass) {
1149   switch (e) {
1150     case EDisplay::Inline:
1151       m_valueID = CSSValueInline;
1152       break;
1153     case EDisplay::Block:
1154       m_valueID = CSSValueBlock;
1155       break;
1156     case EDisplay::ListItem:
1157       m_valueID = CSSValueListItem;
1158       break;
1159     case EDisplay::InlineBlock:
1160       m_valueID = CSSValueInlineBlock;
1161       break;
1162     case EDisplay::Table:
1163       m_valueID = CSSValueTable;
1164       break;
1165     case EDisplay::InlineTable:
1166       m_valueID = CSSValueInlineTable;
1167       break;
1168     case EDisplay::TableRowGroup:
1169       m_valueID = CSSValueTableRowGroup;
1170       break;
1171     case EDisplay::TableHeaderGroup:
1172       m_valueID = CSSValueTableHeaderGroup;
1173       break;
1174     case EDisplay::TableFooterGroup:
1175       m_valueID = CSSValueTableFooterGroup;
1176       break;
1177     case EDisplay::TableRow:
1178       m_valueID = CSSValueTableRow;
1179       break;
1180     case EDisplay::TableColumnGroup:
1181       m_valueID = CSSValueTableColumnGroup;
1182       break;
1183     case EDisplay::TableColumn:
1184       m_valueID = CSSValueTableColumn;
1185       break;
1186     case EDisplay::TableCell:
1187       m_valueID = CSSValueTableCell;
1188       break;
1189     case EDisplay::TableCaption:
1190       m_valueID = CSSValueTableCaption;
1191       break;
1192     case EDisplay::Box:
1193       m_valueID = CSSValueWebkitBox;
1194       break;
1195     case EDisplay::InlineBox:
1196       m_valueID = CSSValueWebkitInlineBox;
1197       break;
1198     case EDisplay::Flex:
1199       m_valueID = CSSValueFlex;
1200       break;
1201     case EDisplay::InlineFlex:
1202       m_valueID = CSSValueInlineFlex;
1203       break;
1204     case EDisplay::Grid:
1205       m_valueID = CSSValueGrid;
1206       break;
1207     case EDisplay::InlineGrid:
1208       m_valueID = CSSValueInlineGrid;
1209       break;
1210     case EDisplay::Contents:
1211       m_valueID = CSSValueContents;
1212       break;
1213     case EDisplay::None:
1214       m_valueID = CSSValueNone;
1215       break;
1216   }
1217 }
1218
1219 template <>
1220 inline EDisplay CSSIdentifierValue::convertTo() const {
1221   if (m_valueID == CSSValueNone)
1222     return EDisplay::None;
1223
1224   if (m_valueID == CSSValueWebkitFlex)
1225     return EDisplay::Flex;
1226   if (m_valueID == CSSValueWebkitInlineFlex)
1227     return EDisplay::InlineFlex;
1228
1229   EDisplay display = static_cast<EDisplay>(m_valueID - CSSValueInline);
1230   // TODO(sashab): Check display is a valid EDisplay here.
1231   return display;
1232 }
1233
1234 template <>
1235 inline CSSIdentifierValue::CSSIdentifierValue(EEmptyCells e)
1236     : CSSValue(IdentifierClass) {
1237   switch (e) {
1238     case EEmptyCells::Show:
1239       m_valueID = CSSValueShow;
1240       break;
1241     case EEmptyCells::Hide:
1242       m_valueID = CSSValueHide;
1243       break;
1244   }
1245 }
1246
1247 template <>
1248 inline EEmptyCells CSSIdentifierValue::convertTo() const {
1249   switch (m_valueID) {
1250     case CSSValueShow:
1251       return EEmptyCells::Show;
1252     case CSSValueHide:
1253       return EEmptyCells::Hide;
1254     default:
1255       break;
1256   }
1257
1258   ASSERT_NOT_REACHED();
1259   return EEmptyCells::Show;
1260 }
1261
1262 template <>
1263 inline CSSIdentifierValue::CSSIdentifierValue(EFlexDirection e)
1264     : CSSValue(IdentifierClass) {
1265   switch (e) {
1266     case FlowRow:
1267       m_valueID = CSSValueRow;
1268       break;
1269     case FlowRowReverse:
1270       m_valueID = CSSValueRowReverse;
1271       break;
1272     case FlowColumn:
1273       m_valueID = CSSValueColumn;
1274       break;
1275     case FlowColumnReverse:
1276       m_valueID = CSSValueColumnReverse;
1277       break;
1278   }
1279 }
1280
1281 template <>
1282 inline EFlexDirection CSSIdentifierValue::convertTo() const {
1283   switch (m_valueID) {
1284     case CSSValueRow:
1285       return FlowRow;
1286     case CSSValueRowReverse:
1287       return FlowRowReverse;
1288     case CSSValueColumn:
1289       return FlowColumn;
1290     case CSSValueColumnReverse:
1291       return FlowColumnReverse;
1292     default:
1293       break;
1294   }
1295
1296   ASSERT_NOT_REACHED();
1297   return FlowRow;
1298 }
1299
1300 template <>
1301 inline CSSIdentifierValue::CSSIdentifierValue(EFlexWrap e)
1302     : CSSValue(IdentifierClass) {
1303   switch (e) {
1304     case FlexNoWrap:
1305       m_valueID = CSSValueNowrap;
1306       break;
1307     case FlexWrap:
1308       m_valueID = CSSValueWrap;
1309       break;
1310     case FlexWrapReverse:
1311       m_valueID = CSSValueWrapReverse;
1312       break;
1313   }
1314 }
1315
1316 template <>
1317 inline EFlexWrap CSSIdentifierValue::convertTo() const {
1318   switch (m_valueID) {
1319     case CSSValueNowrap:
1320       return FlexNoWrap;
1321     case CSSValueWrap:
1322       return FlexWrap;
1323     case CSSValueWrapReverse:
1324       return FlexWrapReverse;
1325     default:
1326       break;
1327   }
1328
1329   ASSERT_NOT_REACHED();
1330   return FlexNoWrap;
1331 }
1332
1333 template <>
1334 inline CSSIdentifierValue::CSSIdentifierValue(EFloat e)
1335     : CSSValue(IdentifierClass) {
1336   switch (e) {
1337     case EFloat::None:
1338       m_valueID = CSSValueNone;
1339       break;
1340     case EFloat::Left:
1341       m_valueID = CSSValueLeft;
1342       break;
1343     case EFloat::Right:
1344       m_valueID = CSSValueRight;
1345       break;
1346   }
1347 }
1348
1349 template <>
1350 inline EFloat CSSIdentifierValue::convertTo() const {
1351   switch (m_valueID) {
1352     case CSSValueLeft:
1353       return EFloat::Left;
1354     case CSSValueRight:
1355       return EFloat::Right;
1356     case CSSValueNone:
1357       return EFloat::None;
1358     default:
1359       break;
1360   }
1361
1362   ASSERT_NOT_REACHED();
1363   return EFloat::None;
1364 }
1365
1366 template <>
1367 inline CSSIdentifierValue::CSSIdentifierValue(Hyphens e)
1368     : CSSValue(IdentifierClass) {
1369   switch (e) {
1370     case HyphensAuto:
1371       m_valueID = CSSValueAuto;
1372       break;
1373     case HyphensManual:
1374       m_valueID = CSSValueManual;
1375       break;
1376     case HyphensNone:
1377       m_valueID = CSSValueNone;
1378       break;
1379   }
1380 }
1381
1382 template <>
1383 inline Hyphens CSSIdentifierValue::convertTo() const {
1384   switch (m_valueID) {
1385     case CSSValueAuto:
1386       return HyphensAuto;
1387     case CSSValueManual:
1388       return HyphensManual;
1389     case CSSValueNone:
1390       return HyphensNone;
1391     default:
1392       break;
1393   }
1394
1395   NOTREACHED();
1396   return HyphensManual;
1397 }
1398
1399 template <>
1400 inline CSSIdentifierValue::CSSIdentifierValue(LineBreak e)
1401     : CSSValue(IdentifierClass) {
1402   switch (e) {
1403     case LineBreakAuto:
1404       m_valueID = CSSValueAuto;
1405       break;
1406     case LineBreakLoose:
1407       m_valueID = CSSValueLoose;
1408       break;
1409     case LineBreakNormal:
1410       m_valueID = CSSValueNormal;
1411       break;
1412     case LineBreakStrict:
1413       m_valueID = CSSValueStrict;
1414       break;
1415     case LineBreakAfterWhiteSpace:
1416       m_valueID = CSSValueAfterWhiteSpace;
1417       break;
1418   }
1419 }
1420
1421 template <>
1422 inline LineBreak CSSIdentifierValue::convertTo() const {
1423   switch (m_valueID) {
1424     case CSSValueAuto:
1425       return LineBreakAuto;
1426     case CSSValueLoose:
1427       return LineBreakLoose;
1428     case CSSValueNormal:
1429       return LineBreakNormal;
1430     case CSSValueStrict:
1431       return LineBreakStrict;
1432     case CSSValueAfterWhiteSpace:
1433       return LineBreakAfterWhiteSpace;
1434     default:
1435       break;
1436   }
1437
1438   ASSERT_NOT_REACHED();
1439   return LineBreakAuto;
1440 }
1441
1442 template <>
1443 inline CSSIdentifierValue::CSSIdentifierValue(EListStylePosition e)
1444     : CSSValue(IdentifierClass) {
1445   switch (e) {
1446     case EListStylePosition::Outside:
1447       m_valueID = CSSValueOutside;
1448       break;
1449     case EListStylePosition::Inside:
1450       m_valueID = CSSValueInside;
1451       break;
1452   }
1453 }
1454
1455 template <>
1456 inline EListStylePosition CSSIdentifierValue::convertTo() const {
1457   switch (m_valueID) {
1458     case CSSValueOutside:
1459       return EListStylePosition::Outside;
1460     case CSSValueInside:
1461       return EListStylePosition::Inside;
1462     default:
1463       break;
1464   }
1465
1466   ASSERT_NOT_REACHED();
1467   return EListStylePosition::Outside;
1468 }
1469
1470 template <>
1471 inline CSSIdentifierValue::CSSIdentifierValue(EListStyleType e)
1472     : CSSValue(IdentifierClass) {
1473   switch (e) {
1474     case EListStyleType::ArabicIndic:
1475       m_valueID = CSSValueArabicIndic;
1476       break;
1477     case EListStyleType::Armenian:
1478       m_valueID = CSSValueArmenian;
1479       break;
1480     case EListStyleType::Bengali:
1481       m_valueID = CSSValueBengali;
1482       break;
1483     case EListStyleType::Cambodian:
1484       m_valueID = CSSValueCambodian;
1485       break;
1486     case EListStyleType::Circle:
1487       m_valueID = CSSValueCircle;
1488       break;
1489     case EListStyleType::CjkEarthlyBranch:
1490       m_valueID = CSSValueCjkEarthlyBranch;
1491       break;
1492     case EListStyleType::CjkHeavenlyStem:
1493       m_valueID = CSSValueCjkHeavenlyStem;
1494       break;
1495     case EListStyleType::CJKIdeographic:
1496       m_valueID = CSSValueCjkIdeographic;
1497       break;
1498     case EListStyleType::DecimalLeadingZero:
1499       m_valueID = CSSValueDecimalLeadingZero;
1500       break;
1501     case EListStyleType::DecimalListStyle:
1502       m_valueID = CSSValueDecimal;
1503       break;
1504     case EListStyleType::Devanagari:
1505       m_valueID = CSSValueDevanagari;
1506       break;
1507     case EListStyleType::Disc:
1508       m_valueID = CSSValueDisc;
1509       break;
1510     case EListStyleType::EthiopicHalehame:
1511       m_valueID = CSSValueEthiopicHalehame;
1512       break;
1513     case EListStyleType::EthiopicHalehameAm:
1514       m_valueID = CSSValueEthiopicHalehameAm;
1515       break;
1516     case EListStyleType::EthiopicHalehameTiEt:
1517       m_valueID = CSSValueEthiopicHalehameTiEt;
1518       break;
1519     case EListStyleType::EthiopicHalehameTiEr:
1520       m_valueID = CSSValueEthiopicHalehameTiEr;
1521       break;
1522     case EListStyleType::Georgian:
1523       m_valueID = CSSValueGeorgian;
1524       break;
1525     case EListStyleType::Gujarati:
1526       m_valueID = CSSValueGujarati;
1527       break;
1528     case EListStyleType::Gurmukhi:
1529       m_valueID = CSSValueGurmukhi;
1530       break;
1531     case EListStyleType::Hangul:
1532       m_valueID = CSSValueHangul;
1533       break;
1534     case EListStyleType::HangulConsonant:
1535       m_valueID = CSSValueHangulConsonant;
1536       break;
1537     case EListStyleType::KoreanHangulFormal:
1538       m_valueID = CSSValueKoreanHangulFormal;
1539       break;
1540     case EListStyleType::KoreanHanjaFormal:
1541       m_valueID = CSSValueKoreanHanjaFormal;
1542       break;
1543     case EListStyleType::KoreanHanjaInformal:
1544       m_valueID = CSSValueKoreanHanjaInformal;
1545       break;
1546     case EListStyleType::Hebrew:
1547       m_valueID = CSSValueHebrew;
1548       break;
1549     case EListStyleType::Hiragana:
1550       m_valueID = CSSValueHiragana;
1551       break;
1552     case EListStyleType::HiraganaIroha:
1553       m_valueID = CSSValueHiraganaIroha;
1554       break;
1555     case EListStyleType::Kannada:
1556       m_valueID = CSSValueKannada;
1557       break;
1558     case EListStyleType::Katakana:
1559       m_valueID = CSSValueKatakana;
1560       break;
1561     case EListStyleType::KatakanaIroha:
1562       m_valueID = CSSValueKatakanaIroha;
1563       break;
1564     case EListStyleType::Khmer:
1565       m_valueID = CSSValueKhmer;
1566       break;
1567     case EListStyleType::Lao:
1568       m_valueID = CSSValueLao;
1569       break;
1570     case EListStyleType::LowerAlpha:
1571       m_valueID = CSSValueLowerAlpha;
1572       break;
1573     case EListStyleType::LowerArmenian:
1574       m_valueID = CSSValueLowerArmenian;
1575       break;
1576     case EListStyleType::LowerGreek:
1577       m_valueID = CSSValueLowerGreek;
1578       break;
1579     case EListStyleType::LowerLatin:
1580       m_valueID = CSSValueLowerLatin;
1581       break;
1582     case EListStyleType::LowerRoman:
1583       m_valueID = CSSValueLowerRoman;
1584       break;
1585     case EListStyleType::Malayalam:
1586       m_valueID = CSSValueMalayalam;
1587       break;
1588     case EListStyleType::Mongolian:
1589       m_valueID = CSSValueMongolian;
1590       break;
1591     case EListStyleType::Myanmar:
1592       m_valueID = CSSValueMyanmar;
1593       break;
1594     case EListStyleType::NoneListStyle:
1595       m_valueID = CSSValueNone;
1596       break;
1597     case EListStyleType::Oriya:
1598       m_valueID = CSSValueOriya;
1599       break;
1600     case EListStyleType::Persian:
1601       m_valueID = CSSValuePersian;
1602       break;
1603     case EListStyleType::SimpChineseFormal:
1604       m_valueID = CSSValueSimpChineseFormal;
1605       break;
1606     case EListStyleType::SimpChineseInformal:
1607       m_valueID = CSSValueSimpChineseInformal;
1608       break;
1609     case EListStyleType::Square:
1610       m_valueID = CSSValueSquare;
1611       break;
1612     case EListStyleType::Telugu:
1613       m_valueID = CSSValueTelugu;
1614       break;
1615     case EListStyleType::Thai:
1616       m_valueID = CSSValueThai;
1617       break;
1618     case EListStyleType::Tibetan:
1619       m_valueID = CSSValueTibetan;
1620       break;
1621     case EListStyleType::TradChineseFormal:
1622       m_valueID = CSSValueTradChineseFormal;
1623       break;
1624     case EListStyleType::TradChineseInformal:
1625       m_valueID = CSSValueTradChineseInformal;
1626       break;
1627     case EListStyleType::UpperAlpha:
1628       m_valueID = CSSValueUpperAlpha;
1629       break;
1630     case EListStyleType::UpperArmenian:
1631       m_valueID = CSSValueUpperArmenian;
1632       break;
1633     case EListStyleType::UpperLatin:
1634       m_valueID = CSSValueUpperLatin;
1635       break;
1636     case EListStyleType::UpperRoman:
1637       m_valueID = CSSValueUpperRoman;
1638       break;
1639     case EListStyleType::Urdu:
1640       m_valueID = CSSValueUrdu;
1641       break;
1642   }
1643 }
1644
1645 template <>
1646 inline EListStyleType CSSIdentifierValue::convertTo() const {
1647   switch (m_valueID) {
1648     case CSSValueNone:
1649       return EListStyleType::NoneListStyle;
1650     case CSSValueArabicIndic:
1651       return EListStyleType::ArabicIndic;
1652     case CSSValueArmenian:
1653       return EListStyleType::Armenian;
1654     case CSSValueBengali:
1655       return EListStyleType::Bengali;
1656     case CSSValueCambodian:
1657       return EListStyleType::Cambodian;
1658     case CSSValueCircle:
1659       return EListStyleType::Circle;
1660     case CSSValueCjkEarthlyBranch:
1661       return EListStyleType::CjkEarthlyBranch;
1662     case CSSValueCjkHeavenlyStem:
1663       return EListStyleType::CjkHeavenlyStem;
1664     case CSSValueCjkIdeographic:
1665       return EListStyleType::CJKIdeographic;
1666     case CSSValueDecimalLeadingZero:
1667       return EListStyleType::DecimalLeadingZero;
1668     case CSSValueDecimal:
1669       return EListStyleType::DecimalListStyle;
1670     case CSSValueDevanagari:
1671       return EListStyleType::Devanagari;
1672     case CSSValueDisc:
1673       return EListStyleType::Disc;
1674     case CSSValueEthiopicHalehame:
1675       return EListStyleType::EthiopicHalehame;
1676     case CSSValueEthiopicHalehameAm:
1677       return EListStyleType::EthiopicHalehameAm;
1678     case CSSValueEthiopicHalehameTiEt:
1679       return EListStyleType::EthiopicHalehameTiEt;
1680     case CSSValueEthiopicHalehameTiEr:
1681       return EListStyleType::EthiopicHalehameTiEr;
1682     case CSSValueGeorgian:
1683       return EListStyleType::Georgian;
1684     case CSSValueGujarati:
1685       return EListStyleType::Gujarati;
1686     case CSSValueGurmukhi:
1687       return EListStyleType::Gurmukhi;
1688     case CSSValueHangul:
1689       return EListStyleType::Hangul;
1690     case CSSValueHangulConsonant:
1691       return EListStyleType::HangulConsonant;
1692     case CSSValueKoreanHangulFormal:
1693       return EListStyleType::KoreanHangulFormal;
1694     case CSSValueKoreanHanjaFormal:
1695       return EListStyleType::KoreanHanjaFormal;
1696     case CSSValueKoreanHanjaInformal:
1697       return EListStyleType::KoreanHanjaInformal;
1698     case CSSValueHebrew:
1699       return EListStyleType::Hebrew;
1700     case CSSValueHiragana:
1701       return EListStyleType::Hiragana;
1702     case CSSValueHiraganaIroha:
1703       return EListStyleType::HiraganaIroha;
1704     case CSSValueKannada:
1705       return EListStyleType::Kannada;
1706     case CSSValueKatakana:
1707       return EListStyleType::Katakana;
1708     case CSSValueKatakanaIroha:
1709       return EListStyleType::KatakanaIroha;
1710     case CSSValueKhmer:
1711       return EListStyleType::Khmer;
1712     case CSSValueLao:
1713       return EListStyleType::Lao;
1714     case CSSValueLowerAlpha:
1715       return EListStyleType::LowerAlpha;
1716     case CSSValueLowerArmenian:
1717       return EListStyleType::LowerArmenian;
1718     case CSSValueLowerGreek:
1719       return EListStyleType::LowerGreek;
1720     case CSSValueLowerLatin:
1721       return EListStyleType::LowerLatin;
1722     case CSSValueLowerRoman:
1723       return EListStyleType::LowerRoman;
1724     case CSSValueMalayalam:
1725       return EListStyleType::Malayalam;
1726     case CSSValueMongolian:
1727       return EListStyleType::Mongolian;
1728     case CSSValueMyanmar:
1729       return EListStyleType::Myanmar;
1730     case CSSValueOriya:
1731       return EListStyleType::Oriya;
1732     case CSSValuePersian:
1733       return EListStyleType::Persian;
1734     case CSSValueSimpChineseFormal:
1735       return EListStyleType::SimpChineseFormal;
1736     case CSSValueSimpChineseInformal:
1737       return EListStyleType::SimpChineseInformal;
1738     case CSSValueSquare:
1739       return EListStyleType::Square;
1740     case CSSValueTelugu:
1741       return EListStyleType::Telugu;
1742     case CSSValueThai:
1743       return EListStyleType::Thai;
1744     case CSSValueTibetan:
1745       return EListStyleType::Tibetan;
1746     case CSSValueTradChineseFormal:
1747       return EListStyleType::TradChineseFormal;
1748     case CSSValueTradChineseInformal:
1749       return EListStyleType::TradChineseInformal;
1750     case CSSValueUpperAlpha:
1751       return EListStyleType::UpperAlpha;
1752     case CSSValueUpperArmenian:
1753       return EListStyleType::UpperArmenian;
1754     case CSSValueUpperLatin:
1755       return EListStyleType::UpperLatin;
1756     case CSSValueUpperRoman:
1757       return EListStyleType::UpperRoman;
1758     case CSSValueUrdu:
1759       return EListStyleType::Urdu;
1760     default:
1761       break;
1762   }
1763
1764   NOTREACHED();
1765   return EListStyleType::NoneListStyle;
1766 }
1767
1768 template <>
1769 inline CSSIdentifierValue::CSSIdentifierValue(EMarginCollapse e)
1770     : CSSValue(IdentifierClass) {
1771   switch (e) {
1772     case MarginCollapseCollapse:
1773       m_valueID = CSSValueCollapse;
1774       break;
1775     case MarginCollapseSeparate:
1776       m_valueID = CSSValueSeparate;
1777       break;
1778     case MarginCollapseDiscard:
1779       m_valueID = CSSValueDiscard;
1780       break;
1781   }
1782 }
1783
1784 template <>
1785 inline EMarginCollapse CSSIdentifierValue::convertTo() const {
1786   switch (m_valueID) {
1787     case CSSValueCollapse:
1788       return MarginCollapseCollapse;
1789     case CSSValueSeparate:
1790       return MarginCollapseSeparate;
1791     case CSSValueDiscard:
1792       return MarginCollapseDiscard;
1793     default:
1794       break;
1795   }
1796
1797   ASSERT_NOT_REACHED();
1798   return MarginCollapseCollapse;
1799 }
1800
1801 template <>
1802 inline CSSIdentifierValue::CSSIdentifierValue(EOverflow e)
1803     : CSSValue(IdentifierClass) {
1804   switch (e) {
1805     case OverflowVisible:
1806       m_valueID = CSSValueVisible;
1807       break;
1808     case OverflowHidden:
1809       m_valueID = CSSValueHidden;
1810       break;
1811     case OverflowScroll:
1812       m_valueID = CSSValueScroll;
1813       break;
1814     case OverflowAuto:
1815       m_valueID = CSSValueAuto;
1816       break;
1817     case OverflowOverlay:
1818       m_valueID = CSSValueOverlay;
1819       break;
1820     case OverflowPagedX:
1821       m_valueID = CSSValueWebkitPagedX;
1822       break;
1823     case OverflowPagedY:
1824       m_valueID = CSSValueWebkitPagedY;
1825       break;
1826   }
1827 }
1828
1829 template <>
1830 inline EOverflow CSSIdentifierValue::convertTo() const {
1831   switch (m_valueID) {
1832     case CSSValueVisible:
1833       return OverflowVisible;
1834     case CSSValueHidden:
1835       return OverflowHidden;
1836     case CSSValueScroll:
1837       return OverflowScroll;
1838     case CSSValueAuto:
1839       return OverflowAuto;
1840     case CSSValueOverlay:
1841       return OverflowOverlay;
1842     case CSSValueWebkitPagedX:
1843       return OverflowPagedX;
1844     case CSSValueWebkitPagedY:
1845       return OverflowPagedY;
1846     default:
1847       break;
1848   }
1849
1850   ASSERT_NOT_REACHED();
1851   return OverflowVisible;
1852 }
1853
1854 template <>
1855 inline CSSIdentifierValue::CSSIdentifierValue(EBreak e)
1856     : CSSValue(IdentifierClass) {
1857   switch (e) {
1858     default:
1859       ASSERT_NOT_REACHED();
1860     case BreakAuto:
1861       m_valueID = CSSValueAuto;
1862       break;
1863     case BreakAlways:
1864       m_valueID = CSSValueAlways;
1865       break;
1866     case BreakAvoid:
1867       m_valueID = CSSValueAvoid;
1868       break;
1869     case BreakAvoidPage:
1870       m_valueID = CSSValueAvoidPage;
1871       break;
1872     case BreakPage:
1873       m_valueID = CSSValuePage;
1874       break;
1875     case BreakLeft:
1876       m_valueID = CSSValueLeft;
1877       break;
1878     case BreakRight:
1879       m_valueID = CSSValueRight;
1880       break;
1881     case BreakRecto:
1882       m_valueID = CSSValueRecto;
1883       break;
1884     case BreakVerso:
1885       m_valueID = CSSValueVerso;
1886       break;
1887     case BreakAvoidColumn:
1888       m_valueID = CSSValueAvoidColumn;
1889       break;
1890     case BreakColumn:
1891       m_valueID = CSSValueColumn;
1892       break;
1893   }
1894 }
1895
1896 template <>
1897 inline EBreak CSSIdentifierValue::convertTo() const {
1898   switch (m_valueID) {
1899     default:
1900       ASSERT_NOT_REACHED();
1901     case CSSValueAuto:
1902       return BreakAuto;
1903     case CSSValueAvoid:
1904       return BreakAvoid;
1905     case CSSValueAlways:
1906       return BreakAlways;
1907     case CSSValueAvoidPage:
1908       return BreakAvoidPage;
1909     case CSSValuePage:
1910       return BreakPage;
1911     case CSSValueLeft:
1912       return BreakLeft;
1913     case CSSValueRight:
1914       return BreakRight;
1915     case CSSValueRecto:
1916       return BreakRecto;
1917     case CSSValueVerso:
1918       return BreakVerso;
1919     case CSSValueAvoidColumn:
1920       return BreakAvoidColumn;
1921     case CSSValueColumn:
1922       return BreakColumn;
1923   }
1924 }
1925
1926 template <>
1927 inline CSSIdentifierValue::CSSIdentifierValue(EPosition e)
1928     : CSSValue(IdentifierClass) {
1929   switch (e) {
1930     case StaticPosition:
1931       m_valueID = CSSValueStatic;
1932       break;
1933     case RelativePosition:
1934       m_valueID = CSSValueRelative;
1935       break;
1936     case AbsolutePosition:
1937       m_valueID = CSSValueAbsolute;
1938       break;
1939     case FixedPosition:
1940       m_valueID = CSSValueFixed;
1941       break;
1942     case StickyPosition:
1943       m_valueID = CSSValueSticky;
1944       break;
1945   }
1946 }
1947
1948 template <>
1949 inline EPosition CSSIdentifierValue::convertTo() const {
1950   switch (m_valueID) {
1951     case CSSValueStatic:
1952       return StaticPosition;
1953     case CSSValueRelative:
1954       return RelativePosition;
1955     case CSSValueAbsolute:
1956       return AbsolutePosition;
1957     case CSSValueFixed:
1958       return FixedPosition;
1959     case CSSValueSticky:
1960       return StickyPosition;
1961     default:
1962       break;
1963   }
1964
1965   ASSERT_NOT_REACHED();
1966   return StaticPosition;
1967 }
1968
1969 template <>
1970 inline CSSIdentifierValue::CSSIdentifierValue(EResize e)
1971     : CSSValue(IdentifierClass) {
1972   switch (e) {
1973     case RESIZE_BOTH:
1974       m_valueID = CSSValueBoth;
1975       break;
1976     case RESIZE_HORIZONTAL:
1977       m_valueID = CSSValueHorizontal;
1978       break;
1979     case RESIZE_VERTICAL:
1980       m_valueID = CSSValueVertical;
1981       break;
1982     case RESIZE_NONE:
1983       m_valueID = CSSValueNone;
1984       break;
1985   }
1986 }
1987
1988 template <>
1989 inline EResize CSSIdentifierValue::convertTo() const {
1990   switch (m_valueID) {
1991     case CSSValueBoth:
1992       return RESIZE_BOTH;
1993     case CSSValueHorizontal:
1994       return RESIZE_HORIZONTAL;
1995     case CSSValueVertical:
1996       return RESIZE_VERTICAL;
1997     case CSSValueAuto:
1998       // Depends on settings, thus should be handled by the caller.
1999       NOTREACHED();
2000       return RESIZE_NONE;
2001     case CSSValueNone:
2002       return RESIZE_NONE;
2003     default:
2004       break;
2005   }
2006
2007   ASSERT_NOT_REACHED();
2008   return RESIZE_NONE;
2009 }
2010
2011 template <>
2012 inline CSSIdentifierValue::CSSIdentifierValue(ETableLayout e)
2013     : CSSValue(IdentifierClass) {
2014   switch (e) {
2015     case TableLayoutAuto:
2016       m_valueID = CSSValueAuto;
2017       break;
2018     case TableLayoutFixed:
2019       m_valueID = CSSValueFixed;
2020       break;
2021   }
2022 }
2023
2024 template <>
2025 inline ETableLayout CSSIdentifierValue::convertTo() const {
2026   switch (m_valueID) {
2027     case CSSValueFixed:
2028       return TableLayoutFixed;
2029     case CSSValueAuto:
2030       return TableLayoutAuto;
2031     default:
2032       break;
2033   }
2034
2035   ASSERT_NOT_REACHED();
2036   return TableLayoutAuto;
2037 }
2038
2039 template <>
2040 inline CSSIdentifierValue::CSSIdentifierValue(ETextAlign e)
2041     : CSSValue(IdentifierClass) {
2042   switch (e) {
2043     case TASTART:
2044       m_valueID = CSSValueStart;
2045       break;
2046     case TAEND:
2047       m_valueID = CSSValueEnd;
2048       break;
2049     case LEFT:
2050       m_valueID = CSSValueLeft;
2051       break;
2052     case RIGHT:
2053       m_valueID = CSSValueRight;
2054       break;
2055     case CENTER:
2056       m_valueID = CSSValueCenter;
2057       break;
2058     case JUSTIFY:
2059       m_valueID = CSSValueJustify;
2060       break;
2061     case WEBKIT_LEFT:
2062       m_valueID = CSSValueWebkitLeft;
2063       break;
2064     case WEBKIT_RIGHT:
2065       m_valueID = CSSValueWebkitRight;
2066       break;
2067     case WEBKIT_CENTER:
2068       m_valueID = CSSValueWebkitCenter;
2069       break;
2070   }
2071 }
2072
2073 template <>
2074 inline ETextAlign CSSIdentifierValue::convertTo() const {
2075   switch (m_valueID) {
2076     case CSSValueWebkitAuto:  // Legacy -webkit-auto. Eqiuvalent to start.
2077     case CSSValueStart:
2078       return TASTART;
2079     case CSSValueEnd:
2080       return TAEND;
2081     case CSSValueInternalCenter:
2082       return CENTER;
2083     default:
2084       return static_cast<ETextAlign>(m_valueID - CSSValueLeft);
2085   }
2086 }
2087
2088 template <>
2089 inline CSSIdentifierValue::CSSIdentifierValue(TextAlignLast e)
2090     : CSSValue(IdentifierClass) {
2091   switch (e) {
2092     case TextAlignLastStart:
2093       m_valueID = CSSValueStart;
2094       break;
2095     case TextAlignLastEnd:
2096       m_valueID = CSSValueEnd;
2097       break;
2098     case TextAlignLastLeft:
2099       m_valueID = CSSValueLeft;
2100       break;
2101     case TextAlignLastRight:
2102       m_valueID = CSSValueRight;
2103       break;
2104     case TextAlignLastCenter:
2105       m_valueID = CSSValueCenter;
2106       break;
2107     case TextAlignLastJustify:
2108       m_valueID = CSSValueJustify;
2109       break;
2110     case TextAlignLastAuto:
2111       m_valueID = CSSValueAuto;
2112       break;
2113   }
2114 }
2115
2116 template <>
2117 inline TextAlignLast CSSIdentifierValue::convertTo() const {
2118   switch (m_valueID) {
2119     case CSSValueAuto:
2120       return TextAlignLastAuto;
2121     case CSSValueStart:
2122       return TextAlignLastStart;
2123     case CSSValueEnd:
2124       return TextAlignLastEnd;
2125     case CSSValueLeft:
2126       return TextAlignLastLeft;
2127     case CSSValueRight:
2128       return TextAlignLastRight;
2129     case CSSValueCenter:
2130       return TextAlignLastCenter;
2131     case CSSValueJustify:
2132       return TextAlignLastJustify;
2133     default:
2134       break;
2135   }
2136
2137   ASSERT_NOT_REACHED();
2138   return TextAlignLastAuto;
2139 }
2140
2141 template <>
2142 inline CSSIdentifierValue::CSSIdentifierValue(TextJustify e)
2143     : CSSValue(IdentifierClass) {
2144   switch (e) {
2145     case TextJustifyAuto:
2146       m_valueID = CSSValueAuto;
2147       break;
2148     case TextJustifyNone:
2149       m_valueID = CSSValueNone;
2150       break;
2151     case TextJustifyInterWord:
2152       m_valueID = CSSValueInterWord;
2153       break;
2154     case TextJustifyDistribute:
2155       m_valueID = CSSValueDistribute;
2156       break;
2157   }
2158 }
2159
2160 template <>
2161 inline TextJustify CSSIdentifierValue::convertTo() const {
2162   switch (m_valueID) {
2163     case CSSValueAuto:
2164       return TextJustifyAuto;
2165     case CSSValueNone:
2166       return TextJustifyNone;
2167     case CSSValueInterWord:
2168       return TextJustifyInterWord;
2169     case CSSValueDistribute:
2170       return TextJustifyDistribute;
2171     default:
2172       break;
2173   }
2174
2175   ASSERT_NOT_REACHED();
2176   return TextJustifyAuto;
2177 }
2178
2179 template <>
2180 inline TextDecoration CSSIdentifierValue::convertTo() const {
2181   switch (m_valueID) {
2182     case CSSValueNone:
2183       return TextDecorationNone;
2184     case CSSValueUnderline:
2185       return TextDecorationUnderline;
2186     case CSSValueOverline:
2187       return TextDecorationOverline;
2188     case CSSValueLineThrough:
2189       return TextDecorationLineThrough;
2190     case CSSValueBlink:
2191       return TextDecorationBlink;
2192     default:
2193       break;
2194   }
2195
2196   ASSERT_NOT_REACHED();
2197   return TextDecorationNone;
2198 }
2199
2200 template <>
2201 inline TextDecorationStyle CSSIdentifierValue::convertTo() const {
2202   switch (m_valueID) {
2203     case CSSValueSolid:
2204       return TextDecorationStyleSolid;
2205     case CSSValueDouble:
2206       return TextDecorationStyleDouble;
2207     case CSSValueDotted:
2208       return TextDecorationStyleDotted;
2209     case CSSValueDashed:
2210       return TextDecorationStyleDashed;
2211     case CSSValueWavy:
2212       return TextDecorationStyleWavy;
2213     default:
2214       break;
2215   }
2216
2217   ASSERT_NOT_REACHED();
2218   return TextDecorationStyleSolid;
2219 }
2220
2221 template <>
2222 inline CSSIdentifierValue::CSSIdentifierValue(TextUnderlinePosition e)
2223     : CSSValue(IdentifierClass) {
2224   switch (e) {
2225     case TextUnderlinePositionAuto:
2226       m_valueID = CSSValueAuto;
2227       break;
2228     case TextUnderlinePositionUnder:
2229       m_valueID = CSSValueUnder;
2230       break;
2231   }
2232
2233   // FIXME: Implement support for 'under left' and 'under right' values.
2234 }
2235
2236 template <>
2237 inline TextUnderlinePosition CSSIdentifierValue::convertTo() const {
2238   switch (m_valueID) {
2239     case CSSValueAuto:
2240       return TextUnderlinePositionAuto;
2241     case CSSValueUnder:
2242       return TextUnderlinePositionUnder;
2243     default:
2244       break;
2245   }
2246
2247   // FIXME: Implement support for 'under left' and 'under right' values.
2248
2249   ASSERT_NOT_REACHED();
2250   return TextUnderlinePositionAuto;
2251 }
2252
2253 template <>
2254 inline TextDecorationSkip CSSIdentifierValue::convertTo() const {
2255   switch (m_valueID) {
2256     case CSSValueObjects:
2257       return TextDecorationSkipObjects;
2258     case CSSValueInk:
2259       return TextDecorationSkipInk;
2260     default:
2261       break;
2262   }
2263
2264   NOTREACHED();
2265   return TextDecorationSkipObjects;
2266 }
2267
2268 template <>
2269 inline CSSIdentifierValue::CSSIdentifierValue(ETextSecurity e)
2270     : CSSValue(IdentifierClass) {
2271   switch (e) {
2272     case TSNONE:
2273       m_valueID = CSSValueNone;
2274       break;
2275     case TSDISC:
2276       m_valueID = CSSValueDisc;
2277       break;
2278     case TSCIRCLE:
2279       m_valueID = CSSValueCircle;
2280       break;
2281     case TSSQUARE:
2282       m_valueID = CSSValueSquare;
2283       break;
2284   }
2285 }
2286
2287 template <>
2288 inline ETextSecurity CSSIdentifierValue::convertTo() const {
2289   switch (m_valueID) {
2290     case CSSValueNone:
2291       return TSNONE;
2292     case CSSValueDisc:
2293       return TSDISC;
2294     case CSSValueCircle:
2295       return TSCIRCLE;
2296     case CSSValueSquare:
2297       return TSSQUARE;
2298     default:
2299       break;
2300   }
2301
2302   ASSERT_NOT_REACHED();
2303   return TSNONE;
2304 }
2305
2306 template <>
2307 inline CSSIdentifierValue::CSSIdentifierValue(ETextTransform e)
2308     : CSSValue(IdentifierClass) {
2309   switch (e) {
2310     case CAPITALIZE:
2311       m_valueID = CSSValueCapitalize;
2312       break;
2313     case UPPERCASE:
2314       m_valueID = CSSValueUppercase;
2315       break;
2316     case LOWERCASE:
2317       m_valueID = CSSValueLowercase;
2318       break;
2319     case TTNONE:
2320       m_valueID = CSSValueNone;
2321       break;
2322   }
2323 }
2324
2325 template <>
2326 inline ETextTransform CSSIdentifierValue::convertTo() const {
2327   switch (m_valueID) {
2328     case CSSValueCapitalize:
2329       return CAPITALIZE;
2330     case CSSValueUppercase:
2331       return UPPERCASE;
2332     case CSSValueLowercase:
2333       return LOWERCASE;
2334     case CSSValueNone:
2335       return TTNONE;
2336     default:
2337       break;
2338   }
2339
2340   ASSERT_NOT_REACHED();
2341   return TTNONE;
2342 }
2343
2344 template <>
2345 inline CSSIdentifierValue::CSSIdentifierValue(EUnicodeBidi e)
2346     : CSSValue(IdentifierClass) {
2347   switch (e) {
2348     case UBNormal:
2349       m_valueID = CSSValueNormal;
2350       break;
2351     case Embed:
2352       m_valueID = CSSValueEmbed;
2353       break;
2354     case Override:
2355       m_valueID = CSSValueBidiOverride;
2356       break;
2357     case Isolate:
2358       m_valueID = CSSValueIsolate;
2359       break;
2360     case IsolateOverride:
2361       m_valueID = CSSValueIsolateOverride;
2362       break;
2363     case Plaintext:
2364       m_valueID = CSSValuePlaintext;
2365       break;
2366   }
2367 }
2368
2369 template <>
2370 inline EUnicodeBidi CSSIdentifierValue::convertTo() const {
2371   switch (m_valueID) {
2372     case CSSValueNormal:
2373       return UBNormal;
2374     case CSSValueEmbed:
2375       return Embed;
2376     case CSSValueBidiOverride:
2377       return Override;
2378     case CSSValueIsolate:
2379     case CSSValueWebkitIsolate:
2380       return Isolate;
2381     case CSSValueIsolateOverride:
2382     case CSSValueWebkitIsolateOverride:
2383       return IsolateOverride;
2384     case CSSValuePlaintext:
2385     case CSSValueWebkitPlaintext:
2386       return Plaintext;
2387     default:
2388       break;
2389   }
2390
2391   ASSERT_NOT_REACHED();
2392   return UBNormal;
2393 }
2394
2395 template <>
2396 inline CSSIdentifierValue::CSSIdentifierValue(EUserDrag e)
2397     : CSSValue(IdentifierClass) {
2398   switch (e) {
2399     case DRAG_AUTO:
2400       m_valueID = CSSValueAuto;
2401       break;
2402     case DRAG_NONE:
2403       m_valueID = CSSValueNone;
2404       break;
2405     case DRAG_ELEMENT:
2406       m_valueID = CSSValueElement;
2407       break;
2408     default:
2409       break;
2410   }
2411 }
2412
2413 template <>
2414 inline EUserDrag CSSIdentifierValue::convertTo() const {
2415   switch (m_valueID) {
2416     case CSSValueAuto:
2417       return DRAG_AUTO;
2418     case CSSValueNone:
2419       return DRAG_NONE;
2420     case CSSValueElement:
2421       return DRAG_ELEMENT;
2422     default:
2423       break;
2424   }
2425
2426   ASSERT_NOT_REACHED();
2427   return DRAG_AUTO;
2428 }
2429
2430 template <>
2431 inline CSSIdentifierValue::CSSIdentifierValue(EUserModify e)
2432     : CSSValue(IdentifierClass) {
2433   switch (e) {
2434     case READ_ONLY:
2435       m_valueID = CSSValueReadOnly;
2436       break;
2437     case READ_WRITE:
2438       m_valueID = CSSValueReadWrite;
2439       break;
2440     case READ_WRITE_PLAINTEXT_ONLY:
2441       m_valueID = CSSValueReadWritePlaintextOnly;
2442       break;
2443   }
2444 }
2445
2446 template <>
2447 inline EUserModify CSSIdentifierValue::convertTo() const {
2448   switch (m_valueID) {
2449     case CSSValueReadOnly:
2450       return READ_ONLY;
2451     case CSSValueReadWrite:
2452       return READ_WRITE;
2453     case CSSValueReadWritePlaintextOnly:
2454       return READ_WRITE_PLAINTEXT_ONLY;
2455     default:
2456       break;
2457   }
2458
2459   ASSERT_NOT_REACHED();
2460   return READ_ONLY;
2461 }
2462
2463 template <>
2464 inline CSSIdentifierValue::CSSIdentifierValue(EUserSelect e)
2465     : CSSValue(IdentifierClass) {
2466   switch (e) {
2467     case SELECT_NONE:
2468       m_valueID = CSSValueNone;
2469       break;
2470     case SELECT_TEXT:
2471       m_valueID = CSSValueText;
2472       break;
2473     case SELECT_ALL:
2474       m_valueID = CSSValueAll;
2475       break;
2476   }
2477 }
2478
2479 template <>
2480 inline EUserSelect CSSIdentifierValue::convertTo() const {
2481   switch (m_valueID) {
2482     case CSSValueAuto:
2483       return SELECT_TEXT;
2484     case CSSValueNone:
2485       return SELECT_NONE;
2486     case CSSValueText:
2487       return SELECT_TEXT;
2488     case CSSValueAll:
2489       return SELECT_ALL;
2490     default:
2491       break;
2492   }
2493
2494   ASSERT_NOT_REACHED();
2495   return SELECT_TEXT;
2496 }
2497
2498 template <>
2499 inline CSSIdentifierValue::CSSIdentifierValue(EVerticalAlign a)
2500     : CSSValue(IdentifierClass) {
2501   switch (a) {
2502     case VerticalAlignTop:
2503       m_valueID = CSSValueTop;
2504       break;
2505     case VerticalAlignBottom:
2506       m_valueID = CSSValueBottom;
2507       break;
2508     case VerticalAlignMiddle:
2509       m_valueID = CSSValueMiddle;
2510       break;
2511     case VerticalAlignBaseline:
2512       m_valueID = CSSValueBaseline;
2513       break;
2514     case VerticalAlignTextBottom:
2515       m_valueID = CSSValueTextBottom;
2516       break;
2517     case VerticalAlignTextTop:
2518       m_valueID = CSSValueTextTop;
2519       break;
2520     case VerticalAlignSub:
2521       m_valueID = CSSValueSub;
2522       break;
2523     case VerticalAlignSuper:
2524       m_valueID = CSSValueSuper;
2525       break;
2526     case VerticalAlignBaselineMiddle:
2527       m_valueID = CSSValueWebkitBaselineMiddle;
2528       break;
2529     case VerticalAlignLength:
2530       m_valueID = CSSValueInvalid;
2531   }
2532 }
2533
2534 template <>
2535 inline EVerticalAlign CSSIdentifierValue::convertTo() const {
2536   switch (m_valueID) {
2537     case CSSValueTop:
2538       return VerticalAlignTop;
2539     case CSSValueBottom:
2540       return VerticalAlignBottom;
2541     case CSSValueMiddle:
2542       return VerticalAlignMiddle;
2543     case CSSValueBaseline:
2544       return VerticalAlignBaseline;
2545     case CSSValueTextBottom:
2546       return VerticalAlignTextBottom;
2547     case CSSValueTextTop:
2548       return VerticalAlignTextTop;
2549     case CSSValueSub:
2550       return VerticalAlignSub;
2551     case CSSValueSuper:
2552       return VerticalAlignSuper;
2553     case CSSValueWebkitBaselineMiddle:
2554       return VerticalAlignBaselineMiddle;
2555     default:
2556       break;
2557   }
2558
2559   ASSERT_NOT_REACHED();
2560   return VerticalAlignTop;
2561 }
2562
2563 template <>
2564 inline CSSIdentifierValue::CSSIdentifierValue(EVisibility e)
2565     : CSSValue(IdentifierClass) {
2566   switch (e) {
2567     case EVisibility::Visible:
2568       m_valueID = CSSValueVisible;
2569       break;
2570     case EVisibility::Hidden:
2571       m_valueID = CSSValueHidden;
2572       break;
2573     case EVisibility::Collapse:
2574       m_valueID = CSSValueCollapse;
2575       break;
2576   }
2577 }
2578
2579 template <>
2580 inline EVisibility CSSIdentifierValue::convertTo() const {
2581   switch (m_valueID) {
2582     case CSSValueHidden:
2583       return EVisibility::Hidden;
2584     case CSSValueVisible:
2585       return EVisibility::Visible;
2586     case CSSValueCollapse:
2587       return EVisibility::Collapse;
2588     default:
2589       break;
2590   }
2591
2592   ASSERT_NOT_REACHED();
2593   return EVisibility::Visible;
2594 }
2595
2596 template <>
2597 inline CSSIdentifierValue::CSSIdentifierValue(EWhiteSpace e)
2598     : CSSValue(IdentifierClass) {
2599   switch (e) {
2600     case NORMAL:
2601       m_valueID = CSSValueNormal;
2602       break;
2603     case PRE:
2604       m_valueID = CSSValuePre;
2605       break;
2606     case PRE_WRAP:
2607       m_valueID = CSSValuePreWrap;
2608       break;
2609     case PRE_LINE:
2610       m_valueID = CSSValuePreLine;
2611       break;
2612     case NOWRAP:
2613       m_valueID = CSSValueNowrap;
2614       break;
2615     case KHTML_NOWRAP:
2616       m_valueID = CSSValueWebkitNowrap;
2617       break;
2618   }
2619 }
2620
2621 template <>
2622 inline EWhiteSpace CSSIdentifierValue::convertTo() const {
2623   switch (m_valueID) {
2624     case CSSValueWebkitNowrap:
2625       return KHTML_NOWRAP;
2626     case CSSValueNowrap:
2627       return NOWRAP;
2628     case CSSValuePre:
2629       return PRE;
2630     case CSSValuePreWrap:
2631       return PRE_WRAP;
2632     case CSSValuePreLine:
2633       return PRE_LINE;
2634     case CSSValueNormal:
2635       return NORMAL;
2636     default:
2637       break;
2638   }
2639
2640   ASSERT_NOT_REACHED();
2641   return NORMAL;
2642 }
2643
2644 template <>
2645 inline CSSIdentifierValue::CSSIdentifierValue(EWordBreak e)
2646     : CSSValue(IdentifierClass) {
2647   switch (e) {
2648     case NormalWordBreak:
2649       m_valueID = CSSValueNormal;
2650       break;
2651     case BreakAllWordBreak:
2652       m_valueID = CSSValueBreakAll;
2653       break;
2654     case BreakWordBreak:
2655       m_valueID = CSSValueBreakWord;
2656       break;
2657     case KeepAllWordBreak:
2658       m_valueID = CSSValueKeepAll;
2659       break;
2660   }
2661 }
2662
2663 template <>
2664 inline EWordBreak CSSIdentifierValue::convertTo() const {
2665   switch (m_valueID) {
2666     case CSSValueBreakAll:
2667       return BreakAllWordBreak;
2668     case CSSValueBreakWord:
2669       return BreakWordBreak;
2670     case CSSValueNormal:
2671       return NormalWordBreak;
2672     case CSSValueKeepAll:
2673       return KeepAllWordBreak;
2674     default:
2675       break;
2676   }
2677
2678   ASSERT_NOT_REACHED();
2679   return NormalWordBreak;
2680 }
2681
2682 template <>
2683 inline CSSIdentifierValue::CSSIdentifierValue(EOverflowAnchor e)
2684     : CSSValue(IdentifierClass) {
2685   switch (e) {
2686     case AnchorVisible:
2687       m_valueID = CSSValueVisible;
2688       break;
2689     case AnchorNone:
2690       m_valueID = CSSValueNone;
2691       break;
2692     case AnchorAuto:
2693       m_valueID = CSSValueAuto;
2694       break;
2695   }
2696 }
2697
2698 template <>
2699 inline EOverflowAnchor CSSIdentifierValue::convertTo() const {
2700   switch (m_valueID) {
2701     case CSSValueVisible:
2702       return AnchorVisible;
2703     case CSSValueNone:
2704       return AnchorNone;
2705     case CSSValueAuto:
2706       return AnchorAuto;
2707     default:
2708       break;
2709   }
2710
2711   NOTREACHED();
2712   return AnchorNone;
2713 }
2714
2715 template <>
2716 inline CSSIdentifierValue::CSSIdentifierValue(EOverflowWrap e)
2717     : CSSValue(IdentifierClass) {
2718   switch (e) {
2719     case NormalOverflowWrap:
2720       m_valueID = CSSValueNormal;
2721       break;
2722     case BreakOverflowWrap:
2723       m_valueID = CSSValueBreakWord;
2724       break;
2725   }
2726 }
2727
2728 template <>
2729 inline EOverflowWrap CSSIdentifierValue::convertTo() const {
2730   switch (m_valueID) {
2731     case CSSValueBreakWord:
2732       return BreakOverflowWrap;
2733     case CSSValueNormal:
2734       return NormalOverflowWrap;
2735     default:
2736       break;
2737   }
2738
2739   ASSERT_NOT_REACHED();
2740   return NormalOverflowWrap;
2741 }
2742
2743 template <>
2744 inline CSSIdentifierValue::CSSIdentifierValue(TextDirection e)
2745     : CSSValue(IdentifierClass) {
2746   switch (e) {
2747     case LTR:
2748       m_valueID = CSSValueLtr;
2749       break;
2750     case RTL:
2751       m_valueID = CSSValueRtl;
2752       break;
2753   }
2754 }
2755
2756 template <>
2757 inline TextDirection CSSIdentifierValue::convertTo() const {
2758   switch (m_valueID) {
2759     case CSSValueLtr:
2760       return LTR;
2761     case CSSValueRtl:
2762       return RTL;
2763     default:
2764       break;
2765   }
2766
2767   ASSERT_NOT_REACHED();
2768   return LTR;
2769 }
2770
2771 template <>
2772 inline CSSIdentifierValue::CSSIdentifierValue(WritingMode e)
2773     : CSSValue(IdentifierClass) {
2774   switch (e) {
2775     case TopToBottomWritingMode:
2776       m_valueID = CSSValueHorizontalTb;
2777       break;
2778     case RightToLeftWritingMode:
2779       m_valueID = CSSValueVerticalRl;
2780       break;
2781     case LeftToRightWritingMode:
2782       m_valueID = CSSValueVerticalLr;
2783       break;
2784   }
2785 }
2786
2787 template <>
2788 inline WritingMode CSSIdentifierValue::convertTo() const {
2789   switch (m_valueID) {
2790     case CSSValueHorizontalTb:
2791     case CSSValueLr:
2792     case CSSValueLrTb:
2793     case CSSValueRl:
2794     case CSSValueRlTb:
2795       return TopToBottomWritingMode;
2796     case CSSValueVerticalRl:
2797     case CSSValueTb:
2798     case CSSValueTbRl:
2799       return RightToLeftWritingMode;
2800     case CSSValueVerticalLr:
2801       return LeftToRightWritingMode;
2802     default:
2803       break;
2804   }
2805
2806   ASSERT_NOT_REACHED();
2807   return TopToBottomWritingMode;
2808 }
2809
2810 template <>
2811 inline CSSIdentifierValue::CSSIdentifierValue(TextCombine e)
2812     : CSSValue(IdentifierClass) {
2813   switch (e) {
2814     case TextCombineNone:
2815       m_valueID = CSSValueNone;
2816       break;
2817     case TextCombineAll:
2818       m_valueID = CSSValueAll;
2819       break;
2820   }
2821 }
2822
2823 template <>
2824 inline TextCombine CSSIdentifierValue::convertTo() const {
2825   switch (m_valueID) {
2826     case CSSValueNone:
2827       return TextCombineNone;
2828     case CSSValueAll:
2829     case CSSValueHorizontal:  // -webkit-text-combine
2830       return TextCombineAll;
2831     default:
2832       break;
2833   }
2834
2835   ASSERT_NOT_REACHED();
2836   return TextCombineNone;
2837 }
2838
2839 template <>
2840 inline CSSIdentifierValue::CSSIdentifierValue(RubyPosition position)
2841     : CSSValue(IdentifierClass) {
2842   switch (position) {
2843     case RubyPositionBefore:
2844       m_valueID = CSSValueBefore;
2845       break;
2846     case RubyPositionAfter:
2847       m_valueID = CSSValueAfter;
2848       break;
2849   }
2850 }
2851
2852 template <>
2853 inline RubyPosition CSSIdentifierValue::convertTo() const {
2854   switch (m_valueID) {
2855     case CSSValueBefore:
2856       return RubyPositionBefore;
2857     case CSSValueAfter:
2858       return RubyPositionAfter;
2859     default:
2860       break;
2861   }
2862
2863   ASSERT_NOT_REACHED();
2864   return RubyPositionBefore;
2865 }
2866
2867 template <>
2868 inline CSSIdentifierValue::CSSIdentifierValue(TextEmphasisPosition position)
2869     : CSSValue(IdentifierClass) {
2870   switch (position) {
2871     case TextEmphasisPositionOver:
2872       m_valueID = CSSValueOver;
2873       break;
2874     case TextEmphasisPositionUnder:
2875       m_valueID = CSSValueUnder;
2876       break;
2877   }
2878 }
2879
2880 template <>
2881 inline TextEmphasisPosition CSSIdentifierValue::convertTo() const {
2882   switch (m_valueID) {
2883     case CSSValueOver:
2884       return TextEmphasisPositionOver;
2885     case CSSValueUnder:
2886       return TextEmphasisPositionUnder;
2887     default:
2888       break;
2889   }
2890
2891   ASSERT_NOT_REACHED();
2892   return TextEmphasisPositionOver;
2893 }
2894
2895 template <>
2896 inline CSSIdentifierValue::CSSIdentifierValue(TextOverflow overflow)
2897     : CSSValue(IdentifierClass) {
2898   switch (overflow) {
2899     case TextOverflowClip:
2900       m_valueID = CSSValueClip;
2901       break;
2902     case TextOverflowEllipsis:
2903       m_valueID = CSSValueEllipsis;
2904       break;
2905   }
2906 }
2907
2908 template <>
2909 inline TextOverflow CSSIdentifierValue::convertTo() const {
2910   switch (m_valueID) {
2911     case CSSValueClip:
2912       return TextOverflowClip;
2913     case CSSValueEllipsis:
2914       return TextOverflowEllipsis;
2915     default:
2916       break;
2917   }
2918
2919   ASSERT_NOT_REACHED();
2920   return TextOverflowClip;
2921 }
2922
2923 template <>
2924 inline CSSIdentifierValue::CSSIdentifierValue(TextEmphasisFill fill)
2925     : CSSValue(IdentifierClass) {
2926   switch (fill) {
2927     case TextEmphasisFillFilled:
2928       m_valueID = CSSValueFilled;
2929       break;
2930     case TextEmphasisFillOpen:
2931       m_valueID = CSSValueOpen;
2932       break;
2933   }
2934 }
2935
2936 template <>
2937 inline TextEmphasisFill CSSIdentifierValue::convertTo() const {
2938   switch (m_valueID) {
2939     case CSSValueFilled:
2940       return TextEmphasisFillFilled;
2941     case CSSValueOpen:
2942       return TextEmphasisFillOpen;
2943     default:
2944       break;
2945   }
2946
2947   ASSERT_NOT_REACHED();
2948   return TextEmphasisFillFilled;
2949 }
2950
2951 template <>
2952 inline CSSIdentifierValue::CSSIdentifierValue(TextEmphasisMark mark)
2953     : CSSValue(IdentifierClass) {
2954   switch (mark) {
2955     case TextEmphasisMarkDot:
2956       m_valueID = CSSValueDot;
2957       break;
2958     case TextEmphasisMarkCircle:
2959       m_valueID = CSSValueCircle;
2960       break;
2961     case TextEmphasisMarkDoubleCircle:
2962       m_valueID = CSSValueDoubleCircle;
2963       break;
2964     case TextEmphasisMarkTriangle:
2965       m_valueID = CSSValueTriangle;
2966       break;
2967     case TextEmphasisMarkSesame:
2968       m_valueID = CSSValueSesame;
2969       break;
2970     case TextEmphasisMarkNone:
2971     case TextEmphasisMarkAuto:
2972     case TextEmphasisMarkCustom:
2973       ASSERT_NOT_REACHED();
2974       m_valueID = CSSValueNone;
2975       break;
2976   }
2977 }
2978
2979 template <>
2980 inline TextEmphasisMark CSSIdentifierValue::convertTo() const {
2981   switch (m_valueID) {
2982     case CSSValueNone:
2983       return TextEmphasisMarkNone;
2984     case CSSValueDot:
2985       return TextEmphasisMarkDot;
2986     case CSSValueCircle:
2987       return TextEmphasisMarkCircle;
2988     case CSSValueDoubleCircle:
2989       return TextEmphasisMarkDoubleCircle;
2990     case CSSValueTriangle:
2991       return TextEmphasisMarkTriangle;
2992     case CSSValueSesame:
2993       return TextEmphasisMarkSesame;
2994     default:
2995       break;
2996   }
2997
2998   ASSERT_NOT_REACHED();
2999   return TextEmphasisMarkNone;
3000 }
3001
3002 template <>
3003 inline CSSIdentifierValue::CSSIdentifierValue(TextOrientation e)
3004     : CSSValue(IdentifierClass) {
3005   switch (e) {
3006     case TextOrientationSideways:
3007       m_valueID = CSSValueSideways;
3008       break;
3009     case TextOrientationMixed:
3010       m_valueID = CSSValueMixed;
3011       break;
3012     case TextOrientationUpright:
3013       m_valueID = CSSValueUpright;
3014       break;
3015   }
3016 }
3017
3018 template <>
3019 inline TextOrientation CSSIdentifierValue::convertTo() const {
3020   switch (m_valueID) {
3021     case CSSValueSideways:
3022     case CSSValueSidewaysRight:
3023       return TextOrientationSideways;
3024     case CSSValueMixed:
3025     case CSSValueVerticalRight:  // -webkit-text-orientation
3026       return TextOrientationMixed;
3027     case CSSValueUpright:
3028       return TextOrientationUpright;
3029     default:
3030       break;
3031   }
3032
3033   ASSERT_NOT_REACHED();
3034   return TextOrientationMixed;
3035 }
3036
3037 template <>
3038 inline CSSIdentifierValue::CSSIdentifierValue(EPointerEvents e)
3039     : CSSValue(IdentifierClass) {
3040   switch (e) {
3041     case PE_NONE:
3042       m_valueID = CSSValueNone;
3043       break;
3044     case PE_STROKE:
3045       m_valueID = CSSValueStroke;
3046       break;
3047     case PE_FILL:
3048       m_valueID = CSSValueFill;
3049       break;
3050     case PE_PAINTED:
3051       m_valueID = CSSValuePainted;
3052       break;
3053     case PE_VISIBLE:
3054       m_valueID = CSSValueVisible;
3055       break;
3056     case PE_VISIBLE_STROKE:
3057       m_valueID = CSSValueVisibleStroke;
3058       break;
3059     case PE_VISIBLE_FILL:
3060       m_valueID = CSSValueVisibleFill;
3061       break;
3062     case PE_VISIBLE_PAINTED:
3063       m_valueID = CSSValueVisiblePainted;
3064       break;
3065     case PE_AUTO:
3066       m_valueID = CSSValueAuto;
3067       break;
3068     case PE_ALL:
3069       m_valueID = CSSValueAll;
3070       break;
3071     case PE_BOUNDINGBOX:
3072       m_valueID = CSSValueBoundingBox;
3073       break;
3074   }
3075 }
3076
3077 template <>
3078 inline EPointerEvents CSSIdentifierValue::convertTo() const {
3079   switch (m_valueID) {
3080     case CSSValueAll:
3081       return PE_ALL;
3082     case CSSValueAuto:
3083       return PE_AUTO;
3084     case CSSValueNone:
3085       return PE_NONE;
3086     case CSSValueVisiblePainted:
3087       return PE_VISIBLE_PAINTED;
3088     case CSSValueVisibleFill:
3089       return PE_VISIBLE_FILL;
3090     case CSSValueVisibleStroke:
3091       return PE_VISIBLE_STROKE;
3092     case CSSValueVisible:
3093       return PE_VISIBLE;
3094     case CSSValuePainted:
3095       return PE_PAINTED;
3096     case CSSValueFill:
3097       return PE_FILL;
3098     case CSSValueStroke:
3099       return PE_STROKE;
3100     case CSSValueBoundingBox:
3101       return PE_BOUNDINGBOX;
3102     default:
3103       break;
3104   }
3105
3106   ASSERT_NOT_REACHED();
3107   return PE_ALL;
3108 }
3109
3110 template <>
3111 inline CSSIdentifierValue::CSSIdentifierValue(FontDescription::Kerning kerning)
3112     : CSSValue(IdentifierClass) {
3113   switch (kerning) {
3114     case FontDescription::AutoKerning:
3115       m_valueID = CSSValueAuto;
3116       return;
3117     case FontDescription::NormalKerning:
3118       m_valueID = CSSValueNormal;
3119       return;
3120     case FontDescription::NoneKerning:
3121       m_valueID = CSSValueNone;
3122       return;
3123   }
3124
3125   ASSERT_NOT_REACHED();
3126   m_valueID = CSSValueAuto;
3127 }
3128
3129 template <>
3130 inline FontDescription::Kerning CSSIdentifierValue::convertTo() const {
3131   switch (m_valueID) {
3132     case CSSValueAuto:
3133       return FontDescription::AutoKerning;
3134     case CSSValueNormal:
3135       return FontDescription::NormalKerning;
3136     case CSSValueNone:
3137       return FontDescription::NoneKerning;
3138     default:
3139       break;
3140   }
3141
3142   ASSERT_NOT_REACHED();
3143   return FontDescription::AutoKerning;
3144 }
3145
3146 template <>
3147 inline CSSIdentifierValue::CSSIdentifierValue(ObjectFit fit)
3148     : CSSValue(IdentifierClass) {
3149   switch (fit) {
3150     case ObjectFitFill:
3151       m_valueID = CSSValueFill;
3152       break;
3153     case ObjectFitContain:
3154       m_valueID = CSSValueContain;
3155       break;
3156     case ObjectFitCover:
3157       m_valueID = CSSValueCover;
3158       break;
3159     case ObjectFitNone:
3160       m_valueID = CSSValueNone;
3161       break;
3162     case ObjectFitScaleDown:
3163       m_valueID = CSSValueScaleDown;
3164       break;
3165   }
3166 }
3167
3168 template <>
3169 inline ObjectFit CSSIdentifierValue::convertTo() const {
3170   switch (m_valueID) {
3171     case CSSValueFill:
3172       return ObjectFitFill;
3173     case CSSValueContain:
3174       return ObjectFitContain;
3175     case CSSValueCover:
3176       return ObjectFitCover;
3177     case CSSValueNone:
3178       return ObjectFitNone;
3179     case CSSValueScaleDown:
3180       return ObjectFitScaleDown;
3181     default:
3182       ASSERT_NOT_REACHED();
3183       return ObjectFitFill;
3184   }
3185 }
3186
3187 template <>
3188 inline CSSIdentifierValue::CSSIdentifierValue(EFillSizeType fillSize)
3189     : CSSValue(IdentifierClass) {
3190   switch (fillSize) {
3191     case Contain:
3192       m_valueID = CSSValueContain;
3193       break;
3194     case Cover:
3195       m_valueID = CSSValueCover;
3196       break;
3197     case SizeNone:
3198       m_valueID = CSSValueNone;
3199       break;
3200     case SizeLength:
3201     default:
3202       ASSERT_NOT_REACHED();
3203   }
3204 }
3205
3206 template <>
3207 inline CSSIdentifierValue::CSSIdentifierValue(FontSmoothingMode smoothing)
3208     : CSSValue(IdentifierClass) {
3209   switch (smoothing) {
3210     case AutoSmoothing:
3211       m_valueID = CSSValueAuto;
3212       return;
3213     case NoSmoothing:
3214       m_valueID = CSSValueNone;
3215       return;
3216     case Antialiased:
3217       m_valueID = CSSValueAntialiased;
3218       return;
3219     case SubpixelAntialiased:
3220       m_valueID = CSSValueSubpixelAntialiased;
3221       return;
3222   }
3223
3224   ASSERT_NOT_REACHED();
3225   m_valueID = CSSValueAuto;
3226 }
3227
3228 template <>
3229 inline FontSmoothingMode CSSIdentifierValue::convertTo() const {
3230   switch (m_valueID) {
3231     case CSSValueAuto:
3232       return AutoSmoothing;
3233     case CSSValueNone:
3234       return NoSmoothing;
3235     case CSSValueAntialiased:
3236       return Antialiased;
3237     case CSSValueSubpixelAntialiased:
3238       return SubpixelAntialiased;
3239     default:
3240       break;
3241   }
3242
3243   ASSERT_NOT_REACHED();
3244   return AutoSmoothing;
3245 }
3246
3247 template <>
3248 inline CSSIdentifierValue::CSSIdentifierValue(FontWeight weight)
3249     : CSSValue(IdentifierClass) {
3250   switch (weight) {
3251     case FontWeight900:
3252       m_valueID = CSSValue900;
3253       return;
3254     case FontWeight800:
3255       m_valueID = CSSValue800;
3256       return;
3257     case FontWeight700:
3258       m_valueID = CSSValueBold;
3259       return;
3260     case FontWeight600:
3261       m_valueID = CSSValue600;
3262       return;
3263     case FontWeight500:
3264       m_valueID = CSSValue500;
3265       return;
3266     case FontWeight400:
3267       m_valueID = CSSValueNormal;
3268       return;
3269     case FontWeight300:
3270       m_valueID = CSSValue300;
3271       return;
3272     case FontWeight200:
3273       m_valueID = CSSValue200;
3274       return;
3275     case FontWeight100:
3276       m_valueID = CSSValue100;
3277       return;
3278   }
3279
3280   ASSERT_NOT_REACHED();
3281   m_valueID = CSSValueNormal;
3282 }
3283
3284 template <>
3285 inline FontWeight CSSIdentifierValue::convertTo() const {
3286   switch (m_valueID) {
3287     case CSSValueBold:
3288       return FontWeightBold;
3289     case CSSValueNormal:
3290       return FontWeightNormal;
3291     case CSSValue900:
3292       return FontWeight900;
3293     case CSSValue800:
3294       return FontWeight800;
3295     case CSSValue700:
3296       return FontWeight700;
3297     case CSSValue600:
3298       return FontWeight600;
3299     case CSSValue500:
3300       return FontWeight500;
3301     case CSSValue400:
3302       return FontWeight400;
3303     case CSSValue300:
3304       return FontWeight300;
3305     case CSSValue200:
3306       return FontWeight200;
3307     case CSSValue100:
3308       return FontWeight100;
3309     default:
3310       break;
3311   }
3312
3313   ASSERT_NOT_REACHED();
3314   return FontWeightNormal;
3315 }
3316
3317 template <>
3318 inline CSSIdentifierValue::CSSIdentifierValue(FontStyle italic)
3319     : CSSValue(IdentifierClass) {
3320   switch (italic) {
3321     case FontStyleNormal:
3322       m_valueID = CSSValueNormal;
3323       return;
3324     case FontStyleOblique:
3325       m_valueID = CSSValueOblique;
3326       return;
3327     case FontStyleItalic:
3328       m_valueID = CSSValueItalic;
3329       return;
3330   }
3331
3332   ASSERT_NOT_REACHED();
3333   m_valueID = CSSValueNormal;
3334 }
3335
3336 template <>
3337 inline FontStyle CSSIdentifierValue::convertTo() const {
3338   switch (m_valueID) {
3339     case CSSValueOblique:
3340       return FontStyleOblique;
3341     case CSSValueItalic:
3342       return FontStyleItalic;
3343     case CSSValueNormal:
3344       return FontStyleNormal;
3345     default:
3346       break;
3347   }
3348   ASSERT_NOT_REACHED();
3349   return FontStyleNormal;
3350 }
3351
3352 template <>
3353 inline CSSIdentifierValue::CSSIdentifierValue(FontStretch stretch)
3354     : CSSValue(IdentifierClass) {
3355   switch (stretch) {
3356     case FontStretchUltraCondensed:
3357       m_valueID = CSSValueUltraCondensed;
3358       return;
3359     case FontStretchExtraCondensed:
3360       m_valueID = CSSValueExtraCondensed;
3361       return;
3362     case FontStretchCondensed:
3363       m_valueID = CSSValueCondensed;
3364       return;
3365     case FontStretchSemiCondensed:
3366       m_valueID = CSSValueSemiCondensed;
3367       return;
3368     case FontStretchNormal:
3369       m_valueID = CSSValueNormal;
3370       return;
3371     case FontStretchSemiExpanded:
3372       m_valueID = CSSValueSemiExpanded;
3373       return;
3374     case FontStretchExpanded:
3375       m_valueID = CSSValueExpanded;
3376       return;
3377     case FontStretchExtraExpanded:
3378       m_valueID = CSSValueExtraExpanded;
3379       return;
3380     case FontStretchUltraExpanded:
3381       m_valueID = CSSValueUltraExpanded;
3382       return;
3383   }
3384
3385   ASSERT_NOT_REACHED();
3386   m_valueID = CSSValueNormal;
3387 }
3388
3389 template <>
3390 inline FontStretch CSSIdentifierValue::convertTo() const {
3391   switch (m_valueID) {
3392     case CSSValueUltraCondensed:
3393       return FontStretchUltraCondensed;
3394     case CSSValueExtraCondensed:
3395       return FontStretchExtraCondensed;
3396     case CSSValueCondensed:
3397       return FontStretchCondensed;
3398     case CSSValueSemiCondensed:
3399       return FontStretchSemiCondensed;
3400     case CSSValueNormal:
3401       return FontStretchNormal;
3402     case CSSValueSemiExpanded:
3403       return FontStretchSemiExpanded;
3404     case CSSValueExpanded:
3405       return FontStretchExpanded;
3406     case CSSValueExtraExpanded:
3407       return FontStretchExtraExpanded;
3408     case CSSValueUltraExpanded:
3409       return FontStretchUltraExpanded;
3410     default:
3411       break;
3412   }
3413
3414   ASSERT_NOT_REACHED();
3415   return FontStretchNormal;
3416 }
3417
3418 template <>
3419 inline CSSIdentifierValue::CSSIdentifierValue(TextRenderingMode e)
3420     : CSSValue(IdentifierClass) {
3421   switch (e) {
3422     case AutoTextRendering:
3423       m_valueID = CSSValueAuto;
3424       break;
3425     case OptimizeSpeed:
3426       m_valueID = CSSValueOptimizeSpeed;
3427       break;
3428     case OptimizeLegibility:
3429       m_valueID = CSSValueOptimizeLegibility;
3430       break;
3431     case GeometricPrecision:
3432       m_valueID = CSSValueGeometricPrecision;
3433       break;
3434   }
3435 }
3436
3437 template <>
3438 inline TextRenderingMode CSSIdentifierValue::convertTo() const {
3439   switch (m_valueID) {
3440     case CSSValueAuto:
3441       return AutoTextRendering;
3442     case CSSValueOptimizeSpeed:
3443       return OptimizeSpeed;
3444     case CSSValueOptimizeLegibility:
3445       return OptimizeLegibility;
3446     case CSSValueGeometricPrecision:
3447       return GeometricPrecision;
3448     default:
3449       break;
3450   }
3451
3452   ASSERT_NOT_REACHED();
3453   return AutoTextRendering;
3454 }
3455
3456 template <>
3457 inline CSSIdentifierValue::CSSIdentifierValue(ESpeak e)
3458     : CSSValue(IdentifierClass) {
3459   switch (e) {
3460     case SpeakNone:
3461       m_valueID = CSSValueNone;
3462       break;
3463     case SpeakNormal:
3464       m_valueID = CSSValueNormal;
3465       break;
3466     case SpeakSpellOut:
3467       m_valueID = CSSValueSpellOut;
3468       break;
3469     case SpeakDigits:
3470       m_valueID = CSSValueDigits;
3471       break;
3472     case SpeakLiteralPunctuation:
3473       m_valueID = CSSValueLiteralPunctuation;
3474       break;
3475     case SpeakNoPunctuation:
3476       m_valueID = CSSValueNoPunctuation;
3477       break;
3478   }
3479 }
3480
3481 template <>
3482 inline Order CSSIdentifierValue::convertTo() const {
3483   switch (m_valueID) {
3484     case CSSValueLogical:
3485       return LogicalOrder;
3486     case CSSValueVisual:
3487       return VisualOrder;
3488     default:
3489       break;
3490   }
3491
3492   ASSERT_NOT_REACHED();
3493   return LogicalOrder;
3494 }
3495
3496 template <>
3497 inline CSSIdentifierValue::CSSIdentifierValue(Order e)
3498     : CSSValue(IdentifierClass) {
3499   switch (e) {
3500     case LogicalOrder:
3501       m_valueID = CSSValueLogical;
3502       break;
3503     case VisualOrder:
3504       m_valueID = CSSValueVisual;
3505       break;
3506   }
3507 }
3508
3509 template <>
3510 inline ESpeak CSSIdentifierValue::convertTo() const {
3511   switch (m_valueID) {
3512     case CSSValueNone:
3513       return SpeakNone;
3514     case CSSValueNormal:
3515       return SpeakNormal;
3516     case CSSValueSpellOut:
3517       return SpeakSpellOut;
3518     case CSSValueDigits:
3519       return SpeakDigits;
3520     case CSSValueLiteralPunctuation:
3521       return SpeakLiteralPunctuation;
3522     case CSSValueNoPunctuation:
3523       return SpeakNoPunctuation;
3524     default:
3525       break;
3526   }
3527
3528   ASSERT_NOT_REACHED();
3529   return SpeakNormal;
3530 }
3531
3532 template <>
3533 inline CSSIdentifierValue::CSSIdentifierValue(WebBlendMode blendMode)
3534     : CSSValue(IdentifierClass) {
3535   switch (blendMode) {
3536     case WebBlendModeNormal:
3537       m_valueID = CSSValueNormal;
3538       break;
3539     case WebBlendModeMultiply:
3540       m_valueID = CSSValueMultiply;
3541       break;
3542     case WebBlendModeScreen:
3543       m_valueID = CSSValueScreen;
3544       break;
3545     case WebBlendModeOverlay:
3546       m_valueID = CSSValueOverlay;
3547       break;
3548     case WebBlendModeDarken:
3549       m_valueID = CSSValueDarken;
3550       break;
3551     case WebBlendModeLighten:
3552       m_valueID = CSSValueLighten;
3553       break;
3554     case WebBlendModeColorDodge:
3555       m_valueID = CSSValueColorDodge;
3556       break;
3557     case WebBlendModeColorBurn:
3558       m_valueID = CSSValueColorBurn;
3559       break;
3560     case WebBlendModeHardLight:
3561       m_valueID = CSSValueHardLight;
3562       break;
3563     case WebBlendModeSoftLight:
3564       m_valueID = CSSValueSoftLight;
3565       break;
3566     case WebBlendModeDifference:
3567       m_valueID = CSSValueDifference;
3568       break;
3569     case WebBlendModeExclusion:
3570       m_valueID = CSSValueExclusion;
3571       break;
3572     case WebBlendModeHue:
3573       m_valueID = CSSValueHue;
3574       break;
3575     case WebBlendModeSaturation:
3576       m_valueID = CSSValueSaturation;
3577       break;
3578     case WebBlendModeColor:
3579       m_valueID = CSSValueColor;
3580       break;
3581     case WebBlendModeLuminosity:
3582       m_valueID = CSSValueLuminosity;
3583       break;
3584   }
3585 }
3586
3587 template <>
3588 inline WebBlendMode CSSIdentifierValue::convertTo() const {
3589   switch (m_valueID) {
3590     case CSSValueNormal:
3591       return WebBlendModeNormal;
3592     case CSSValueMultiply:
3593       return WebBlendModeMultiply;
3594     case CSSValueScreen:
3595       return WebBlendModeScreen;
3596     case CSSValueOverlay:
3597       return WebBlendModeOverlay;
3598     case CSSValueDarken:
3599       return WebBlendModeDarken;
3600     case CSSValueLighten:
3601       return WebBlendModeLighten;
3602     case CSSValueColorDodge:
3603       return WebBlendModeColorDodge;
3604     case CSSValueColorBurn:
3605       return WebBlendModeColorBurn;
3606     case CSSValueHardLight:
3607       return WebBlendModeHardLight;
3608     case CSSValueSoftLight:
3609       return WebBlendModeSoftLight;
3610     case CSSValueDifference:
3611       return WebBlendModeDifference;
3612     case CSSValueExclusion:
3613       return WebBlendModeExclusion;
3614     case CSSValueHue:
3615       return WebBlendModeHue;
3616     case CSSValueSaturation:
3617       return WebBlendModeSaturation;
3618     case CSSValueColor:
3619       return WebBlendModeColor;
3620     case CSSValueLuminosity:
3621       return WebBlendModeLuminosity;
3622     default:
3623       break;
3624   }
3625
3626   ASSERT_NOT_REACHED();
3627   return WebBlendModeNormal;
3628 }
3629
3630 template <>
3631 inline CSSIdentifierValue::CSSIdentifierValue(LineCap e)
3632     : CSSValue(IdentifierClass) {
3633   switch (e) {
3634     case ButtCap:
3635       m_valueID = CSSValueButt;
3636       break;
3637     case RoundCap:
3638       m_valueID = CSSValueRound;
3639       break;
3640     case SquareCap:
3641       m_valueID = CSSValueSquare;
3642       break;
3643   }
3644 }
3645
3646 template <>
3647 inline LineCap CSSIdentifierValue::convertTo() const {
3648   switch (m_valueID) {
3649     case CSSValueButt:
3650       return ButtCap;
3651     case CSSValueRound:
3652       return RoundCap;
3653     case CSSValueSquare:
3654       return SquareCap;
3655     default:
3656       break;
3657   }
3658
3659   ASSERT_NOT_REACHED();
3660   return ButtCap;
3661 }
3662
3663 template <>
3664 inline CSSIdentifierValue::CSSIdentifierValue(LineJoin e)
3665     : CSSValue(IdentifierClass) {
3666   switch (e) {
3667     case MiterJoin:
3668       m_valueID = CSSValueMiter;
3669       break;
3670     case RoundJoin:
3671       m_valueID = CSSValueRound;
3672       break;
3673     case BevelJoin:
3674       m_valueID = CSSValueBevel;
3675       break;
3676   }
3677 }
3678
3679 template <>
3680 inline LineJoin CSSIdentifierValue::convertTo() const {
3681   switch (m_valueID) {
3682     case CSSValueMiter:
3683       return MiterJoin;
3684     case CSSValueRound:
3685       return RoundJoin;
3686     case CSSValueBevel:
3687       return BevelJoin;
3688     default:
3689       break;
3690   }
3691
3692   ASSERT_NOT_REACHED();
3693   return MiterJoin;
3694 }
3695
3696 template <>
3697 inline CSSIdentifierValue::CSSIdentifierValue(WindRule e)
3698     : CSSValue(IdentifierClass) {
3699   switch (e) {
3700     case RULE_NONZERO:
3701       m_valueID = CSSValueNonzero;
3702       break;
3703     case RULE_EVENODD:
3704       m_valueID = CSSValueEvenodd;
3705       break;
3706   }
3707 }
3708
3709 template <>
3710 inline WindRule CSSIdentifierValue::convertTo() const {
3711   switch (m_valueID) {
3712     case CSSValueNonzero:
3713       return RULE_NONZERO;
3714     case CSSValueEvenodd:
3715       return RULE_EVENODD;
3716     default:
3717       break;
3718   }
3719
3720   ASSERT_NOT_REACHED();
3721   return RULE_NONZERO;
3722 }
3723
3724 template <>
3725 inline CSSIdentifierValue::CSSIdentifierValue(EAlignmentBaseline e)
3726     : CSSValue(IdentifierClass) {
3727   switch (e) {
3728     case AB_AUTO:
3729       m_valueID = CSSValueAuto;
3730       break;
3731     case AB_BASELINE:
3732       m_valueID = CSSValueBaseline;
3733       break;
3734     case AB_BEFORE_EDGE:
3735       m_valueID = CSSValueBeforeEdge;
3736       break;
3737     case AB_TEXT_BEFORE_EDGE:
3738       m_valueID = CSSValueTextBeforeEdge;
3739       break;
3740     case AB_MIDDLE:
3741       m_valueID = CSSValueMiddle;
3742       break;
3743     case AB_CENTRAL:
3744       m_valueID = CSSValueCentral;
3745       break;
3746     case AB_AFTER_EDGE:
3747       m_valueID = CSSValueAfterEdge;
3748       break;
3749     case AB_TEXT_AFTER_EDGE:
3750       m_valueID = CSSValueTextAfterEdge;
3751       break;
3752     case AB_IDEOGRAPHIC:
3753       m_valueID = CSSValueIdeographic;
3754       break;
3755     case AB_ALPHABETIC:
3756       m_valueID = CSSValueAlphabetic;
3757       break;
3758     case AB_HANGING:
3759       m_valueID = CSSValueHanging;
3760       break;
3761     case AB_MATHEMATICAL:
3762       m_valueID = CSSValueMathematical;
3763       break;
3764   }
3765 }
3766
3767 template <>
3768 inline EAlignmentBaseline CSSIdentifierValue::convertTo() const {
3769   switch (m_valueID) {
3770     case CSSValueAuto:
3771       return AB_AUTO;
3772     case CSSValueBaseline:
3773       return AB_BASELINE;
3774     case CSSValueBeforeEdge:
3775       return AB_BEFORE_EDGE;
3776     case CSSValueTextBeforeEdge:
3777       return AB_TEXT_BEFORE_EDGE;
3778     case CSSValueMiddle:
3779       return AB_MIDDLE;
3780     case CSSValueCentral:
3781       return AB_CENTRAL;
3782     case CSSValueAfterEdge:
3783       return AB_AFTER_EDGE;
3784     case CSSValueTextAfterEdge:
3785       return AB_TEXT_AFTER_EDGE;
3786     case CSSValueIdeographic:
3787       return AB_IDEOGRAPHIC;
3788     case CSSValueAlphabetic:
3789       return AB_ALPHABETIC;
3790     case CSSValueHanging:
3791       return AB_HANGING;
3792     case CSSValueMathematical:
3793       return AB_MATHEMATICAL;
3794     default:
3795       break;
3796   }
3797
3798   ASSERT_NOT_REACHED();
3799   return AB_AUTO;
3800 }
3801
3802 template <>
3803 inline CSSIdentifierValue::CSSIdentifierValue(EBorderCollapse e)
3804     : CSSValue(IdentifierClass) {
3805   switch (e) {
3806     case BorderCollapseSeparate:
3807       m_valueID = CSSValueSeparate;
3808       break;
3809     case BorderCollapseCollapse:
3810       m_valueID = CSSValueCollapse;
3811       break;
3812   }
3813 }
3814
3815 template <>
3816 inline EBorderCollapse CSSIdentifierValue::convertTo() const {
3817   switch (m_valueID) {
3818     case CSSValueSeparate:
3819       return BorderCollapseSeparate;
3820     case CSSValueCollapse:
3821       return BorderCollapseCollapse;
3822     default:
3823       break;
3824   }
3825
3826   ASSERT_NOT_REACHED();
3827   return BorderCollapseSeparate;
3828 }
3829
3830 template <>
3831 inline CSSIdentifierValue::CSSIdentifierValue(EImageRendering e)
3832     : CSSValue(IdentifierClass) {
3833   switch (e) {
3834     case ImageRenderingAuto:
3835       m_valueID = CSSValueAuto;
3836       break;
3837     case ImageRenderingOptimizeSpeed:
3838       m_valueID = CSSValueOptimizeSpeed;
3839       break;
3840     case ImageRenderingOptimizeQuality:
3841       m_valueID = CSSValueOptimizeQuality;
3842       break;
3843     case ImageRenderingPixelated:
3844       m_valueID = CSSValuePixelated;
3845       break;
3846     case ImageRenderingOptimizeContrast:
3847       m_valueID = CSSValueWebkitOptimizeContrast;
3848       break;
3849   }
3850 }
3851
3852 template <>
3853 inline EImageRendering CSSIdentifierValue::convertTo() const {
3854   switch (m_valueID) {
3855     case CSSValueAuto:
3856       return ImageRenderingAuto;
3857     case CSSValueOptimizeSpeed:
3858       return ImageRenderingOptimizeSpeed;
3859     case CSSValueOptimizeQuality:
3860       return ImageRenderingOptimizeQuality;
3861     case CSSValuePixelated:
3862       return ImageRenderingPixelated;
3863     case CSSValueWebkitOptimizeContrast:
3864       return ImageRenderingOptimizeContrast;
3865     default:
3866       break;
3867   }
3868
3869   ASSERT_NOT_REACHED();
3870   return ImageRenderingAuto;
3871 }
3872
3873 template <>
3874 inline CSSIdentifierValue::CSSIdentifierValue(ETransformStyle3D e)
3875     : CSSValue(IdentifierClass) {
3876   switch (e) {
3877     case TransformStyle3DFlat:
3878       m_valueID = CSSValueFlat;
3879       break;
3880     case TransformStyle3DPreserve3D:
3881       m_valueID = CSSValuePreserve3d;
3882       break;
3883   }
3884 }
3885
3886 template <>
3887 inline ETransformStyle3D CSSIdentifierValue::convertTo() const {
3888   switch (m_valueID) {
3889     case CSSValueFlat:
3890       return TransformStyle3DFlat;
3891     case CSSValuePreserve3d:
3892       return TransformStyle3DPreserve3D;
3893     default:
3894       break;
3895   }
3896
3897   ASSERT_NOT_REACHED();
3898   return TransformStyle3DFlat;
3899 }
3900
3901 template <>
3902 inline CSSIdentifierValue::CSSIdentifierValue(EBufferedRendering e)
3903     : CSSValue(IdentifierClass) {
3904   switch (e) {
3905     case BR_AUTO:
3906       m_valueID = CSSValueAuto;
3907       break;
3908     case BR_DYNAMIC:
3909       m_valueID = CSSValueDynamic;
3910       break;
3911     case BR_STATIC:
3912       m_valueID = CSSValueStatic;
3913       break;
3914   }
3915 }
3916
3917 template <>
3918 inline EBufferedRendering CSSIdentifierValue::convertTo() const {
3919   switch (m_valueID) {
3920     case CSSValueAuto:
3921       return BR_AUTO;
3922     case CSSValueDynamic:
3923       return BR_DYNAMIC;
3924     case CSSValueStatic:
3925       return BR_STATIC;
3926     default:
3927       break;
3928   }
3929
3930   ASSERT_NOT_REACHED();
3931   return BR_AUTO;
3932 }
3933
3934 template <>
3935 inline CSSIdentifierValue::CSSIdentifierValue(EColorInterpolation e)
3936     : CSSValue(IdentifierClass) {
3937   switch (e) {
3938     case CI_AUTO:
3939       m_valueID = CSSValueAuto;
3940       break;
3941     case CI_SRGB:
3942       m_valueID = CSSValueSRGB;
3943       break;
3944     case CI_LINEARRGB:
3945       m_valueID = CSSValueLinearRGB;
3946       break;
3947   }
3948 }
3949
3950 template <>
3951 inline EColorInterpolation CSSIdentifierValue::convertTo() const {
3952   switch (m_valueID) {
3953     case CSSValueSRGB:
3954       return CI_SRGB;
3955     case CSSValueLinearRGB:
3956       return CI_LINEARRGB;
3957     case CSSValueAuto:
3958       return CI_AUTO;
3959     default:
3960       break;
3961   }
3962
3963   ASSERT_NOT_REACHED();
3964   return CI_AUTO;
3965 }
3966
3967 template <>
3968 inline CSSIdentifierValue::CSSIdentifierValue(EColorRendering e)
3969     : CSSValue(IdentifierClass) {
3970   switch (e) {
3971     case CR_AUTO:
3972       m_valueID = CSSValueAuto;
3973       break;
3974     case CR_OPTIMIZESPEED:
3975       m_valueID = CSSValueOptimizeSpeed;
3976       break;
3977     case CR_OPTIMIZEQUALITY:
3978       m_valueID = CSSValueOptimizeQuality;
3979       break;
3980   }
3981 }
3982
3983 template <>
3984 inline EColorRendering CSSIdentifierValue::convertTo() const {
3985   switch (m_valueID) {
3986     case CSSValueOptimizeSpeed:
3987       return CR_OPTIMIZESPEED;
3988     case CSSValueOptimizeQuality:
3989       return CR_OPTIMIZEQUALITY;
3990     case CSSValueAuto:
3991       return CR_AUTO;
3992     default:
3993       break;
3994   }
3995
3996   ASSERT_NOT_REACHED();
3997   return CR_AUTO;
3998 }
3999
4000 template <>
4001 inline CSSIdentifierValue::CSSIdentifierValue(EDominantBaseline e)
4002     : CSSValue(IdentifierClass) {
4003   switch (e) {
4004     case DB_AUTO:
4005       m_valueID = CSSValueAuto;
4006       break;
4007     case DB_USE_SCRIPT:
4008       m_valueID = CSSValueUseScript;
4009       break;
4010     case DB_NO_CHANGE:
4011       m_valueID = CSSValueNoChange;
4012       break;
4013     case DB_RESET_SIZE:
4014       m_valueID = CSSValueResetSize;
4015       break;
4016     case DB_CENTRAL:
4017       m_valueID = CSSValueCentral;
4018       break;
4019     case DB_MIDDLE:
4020       m_valueID = CSSValueMiddle;
4021       break;
4022     case DB_TEXT_BEFORE_EDGE:
4023       m_valueID = CSSValueTextBeforeEdge;
4024       break;
4025     case DB_TEXT_AFTER_EDGE:
4026       m_valueID = CSSValueTextAfterEdge;
4027       break;
4028     case DB_IDEOGRAPHIC:
4029       m_valueID = CSSValueIdeographic;
4030       break;
4031     case DB_ALPHABETIC:
4032       m_valueID = CSSValueAlphabetic;
4033       break;
4034     case DB_HANGING:
4035       m_valueID = CSSValueHanging;
4036       break;
4037     case DB_MATHEMATICAL:
4038       m_valueID = CSSValueMathematical;
4039       break;
4040   }
4041 }
4042
4043 template <>
4044 inline EDominantBaseline CSSIdentifierValue::convertTo() const {
4045   switch (m_valueID) {
4046     case CSSValueAuto:
4047       return DB_AUTO;
4048     case CSSValueUseScript:
4049       return DB_USE_SCRIPT;
4050     case CSSValueNoChange:
4051       return DB_NO_CHANGE;
4052     case CSSValueResetSize:
4053       return DB_RESET_SIZE;
4054     case CSSValueIdeographic:
4055       return DB_IDEOGRAPHIC;
4056     case CSSValueAlphabetic:
4057       return DB_ALPHABETIC;
4058     case CSSValueHanging:
4059       return DB_HANGING;
4060     case CSSValueMathematical:
4061       return DB_MATHEMATICAL;
4062     case CSSValueCentral:
4063       return DB_CENTRAL;
4064     case CSSValueMiddle:
4065       return DB_MIDDLE;
4066     case CSSValueTextAfterEdge:
4067       return DB_TEXT_AFTER_EDGE;
4068     case CSSValueTextBeforeEdge:
4069       return DB_TEXT_BEFORE_EDGE;
4070     default:
4071       break;
4072   }
4073
4074   ASSERT_NOT_REACHED();
4075   return DB_AUTO;
4076 }
4077
4078 template <>
4079 inline CSSIdentifierValue::CSSIdentifierValue(EShapeRendering e)
4080     : CSSValue(IdentifierClass) {
4081   switch (e) {
4082     case SR_AUTO:
4083       m_valueID = CSSValueAuto;
4084       break;
4085     case SR_OPTIMIZESPEED:
4086       m_valueID = CSSValueOptimizeSpeed;
4087       break;
4088     case SR_CRISPEDGES:
4089       m_valueID = CSSValueCrispEdges;
4090       break;
4091     case SR_GEOMETRICPRECISION:
4092       m_valueID = CSSValueGeometricPrecision;
4093       break;
4094   }
4095 }
4096
4097 template <>
4098 inline EShapeRendering CSSIdentifierValue::convertTo() const {
4099   switch (m_valueID) {
4100     case CSSValueAuto:
4101       return SR_AUTO;
4102     case CSSValueOptimizeSpeed:
4103       return SR_OPTIMIZESPEED;
4104     case CSSValueCrispEdges:
4105       return SR_CRISPEDGES;
4106     case CSSValueGeometricPrecision:
4107       return SR_GEOMETRICPRECISION;
4108     default:
4109       break;
4110   }
4111
4112   ASSERT_NOT_REACHED();
4113   return SR_AUTO;
4114 }
4115
4116 template <>
4117 inline CSSIdentifierValue::CSSIdentifierValue(ETextAnchor e)
4118     : CSSValue(IdentifierClass) {
4119   switch (e) {
4120     case TA_START:
4121       m_valueID = CSSValueStart;
4122       break;
4123     case TA_MIDDLE:
4124       m_valueID = CSSValueMiddle;
4125       break;
4126     case TA_END:
4127       m_valueID = CSSValueEnd;
4128       break;
4129   }
4130 }
4131
4132 template <>
4133 inline ETextAnchor CSSIdentifierValue::convertTo() const {
4134   switch (m_valueID) {
4135     case CSSValueStart:
4136       return TA_START;
4137     case CSSValueMiddle:
4138       return TA_MIDDLE;
4139     case CSSValueEnd:
4140       return TA_END;
4141     default:
4142       break;
4143   }
4144
4145   ASSERT_NOT_REACHED();
4146   return TA_START;
4147 }
4148
4149 template <>
4150 inline CSSIdentifierValue::CSSIdentifierValue(EVectorEffect e)
4151     : CSSValue(IdentifierClass) {
4152   switch (e) {
4153     case VE_NONE:
4154       m_valueID = CSSValueNone;
4155       break;
4156     case VE_NON_SCALING_STROKE:
4157       m_valueID = CSSValueNonScalingStroke;
4158       break;
4159   }
4160 }
4161
4162 template <>
4163 inline EVectorEffect CSSIdentifierValue::convertTo() const {
4164   switch (m_valueID) {
4165     case CSSValueNone:
4166       return VE_NONE;
4167     case CSSValueNonScalingStroke:
4168       return VE_NON_SCALING_STROKE;
4169     default:
4170       break;
4171   }
4172
4173   ASSERT_NOT_REACHED();
4174   return VE_NONE;
4175 }
4176
4177 template <>
4178 inline CSSIdentifierValue::CSSIdentifierValue(EPaintOrderType e)
4179     : CSSValue(IdentifierClass) {
4180   switch (e) {
4181     case PT_FILL:
4182       m_valueID = CSSValueFill;
4183       break;
4184     case PT_STROKE:
4185       m_valueID = CSSValueStroke;
4186       break;
4187     case PT_MARKERS:
4188       m_valueID = CSSValueMarkers;
4189       break;
4190     default:
4191       ASSERT_NOT_REACHED();
4192       m_valueID = CSSValueFill;
4193       break;
4194   }
4195 }
4196
4197 template <>
4198 inline EPaintOrderType CSSIdentifierValue::convertTo() const {
4199   switch (m_valueID) {
4200     case CSSValueFill:
4201       return PT_FILL;
4202     case CSSValueStroke:
4203       return PT_STROKE;
4204     case CSSValueMarkers:
4205       return PT_MARKERS;
4206     default:
4207       break;
4208   }
4209
4210   ASSERT_NOT_REACHED();
4211   return PT_NONE;
4212 }
4213
4214 template <>
4215 inline CSSIdentifierValue::CSSIdentifierValue(EMaskType e)
4216     : CSSValue(IdentifierClass) {
4217   switch (e) {
4218     case MT_LUMINANCE:
4219       m_valueID = CSSValueLuminance;
4220       break;
4221     case MT_ALPHA:
4222       m_valueID = CSSValueAlpha;
4223       break;
4224   }
4225 }
4226
4227 template <>
4228 inline EMaskType CSSIdentifierValue::convertTo() const {
4229   switch (m_valueID) {
4230     case CSSValueLuminance:
4231       return MT_LUMINANCE;
4232     case CSSValueAlpha:
4233       return MT_ALPHA;
4234     default:
4235       break;
4236   }
4237
4238   ASSERT_NOT_REACHED();
4239   return MT_LUMINANCE;
4240 }
4241
4242 template <>
4243 inline TouchAction CSSIdentifierValue::convertTo() const {
4244   switch (m_valueID) {
4245     case CSSValueNone:
4246       return TouchActionNone;
4247     case CSSValueAuto:
4248       return TouchActionAuto;
4249     case CSSValuePanLeft:
4250       return TouchActionPanLeft;
4251     case CSSValuePanRight:
4252       return TouchActionPanRight;
4253     case CSSValuePanX:
4254       return TouchActionPanX;
4255     case CSSValuePanUp:
4256       return TouchActionPanUp;
4257     case CSSValuePanDown:
4258       return TouchActionPanDown;
4259     case CSSValuePanY:
4260       return TouchActionPanY;
4261     case CSSValueManipulation:
4262       return TouchActionManipulation;
4263     case CSSValuePinchZoom:
4264       return TouchActionPinchZoom;
4265     default:
4266       break;
4267   }
4268
4269   ASSERT_NOT_REACHED();
4270   return TouchActionNone;
4271 }
4272
4273 template <>
4274 inline CSSIdentifierValue::CSSIdentifierValue(EIsolation i)
4275     : CSSValue(IdentifierClass) {
4276   switch (i) {
4277     case IsolationAuto:
4278       m_valueID = CSSValueAuto;
4279       break;
4280     case IsolationIsolate:
4281       m_valueID = CSSValueIsolate;
4282       break;
4283   }
4284 }
4285
4286 template <>
4287 inline EIsolation CSSIdentifierValue::convertTo() const {
4288   switch (m_valueID) {
4289     case CSSValueAuto:
4290       return IsolationAuto;
4291     case CSSValueIsolate:
4292       return IsolationIsolate;
4293     default:
4294       break;
4295   }
4296
4297   ASSERT_NOT_REACHED();
4298   return IsolationAuto;
4299 }
4300
4301 template <>
4302 inline CSSIdentifierValue::CSSIdentifierValue(CSSBoxType cssBox)
4303     : CSSValue(IdentifierClass) {
4304   switch (cssBox) {
4305     case MarginBox:
4306       m_valueID = CSSValueMarginBox;
4307       break;
4308     case BorderBox:
4309       m_valueID = CSSValueBorderBox;
4310       break;
4311     case PaddingBox:
4312       m_valueID = CSSValuePaddingBox;
4313       break;
4314     case ContentBox:
4315       m_valueID = CSSValueContentBox;
4316       break;
4317     case BoxMissing:
4318       // The missing box should convert to a null primitive value.
4319       ASSERT_NOT_REACHED();
4320   }
4321 }
4322
4323 template <>
4324 inline CSSBoxType CSSIdentifierValue::convertTo() const {
4325   switch (getValueID()) {
4326     case CSSValueMarginBox:
4327       return MarginBox;
4328     case CSSValueBorderBox:
4329       return BorderBox;
4330     case CSSValuePaddingBox:
4331       return PaddingBox;
4332     case CSSValueContentBox:
4333       return ContentBox;
4334     default:
4335       break;
4336   }
4337   ASSERT_NOT_REACHED();
4338   return ContentBox;
4339 }
4340
4341 template <>
4342 inline CSSIdentifierValue::CSSIdentifierValue(ItemPosition itemPosition)
4343     : CSSValue(IdentifierClass) {
4344   switch (itemPosition) {
4345     case ItemPositionAuto:
4346       // The 'auto' values might have been already resolved.
4347       NOTREACHED();
4348       m_valueID = CSSValueNormal;
4349       break;
4350     case ItemPositionNormal:
4351       m_valueID = CSSValueNormal;
4352       break;
4353     case ItemPositionStretch:
4354       m_valueID = CSSValueStretch;
4355       break;
4356     case ItemPositionBaseline:
4357       m_valueID = CSSValueBaseline;
4358       break;
4359     case ItemPositionLastBaseline:
4360       m_valueID = CSSValueLastBaseline;
4361       break;
4362     case ItemPositionCenter:
4363       m_valueID = CSSValueCenter;
4364       break;
4365     case ItemPositionStart:
4366       m_valueID = CSSValueStart;
4367       break;
4368     case ItemPositionEnd:
4369       m_valueID = CSSValueEnd;
4370       break;
4371     case ItemPositionSelfStart:
4372       m_valueID = CSSValueSelfStart;
4373       break;
4374     case ItemPositionSelfEnd:
4375       m_valueID = CSSValueSelfEnd;
4376       break;
4377     case ItemPositionFlexStart:
4378       m_valueID = CSSValueFlexStart;
4379       break;
4380     case ItemPositionFlexEnd:
4381       m_valueID = CSSValueFlexEnd;
4382       break;
4383     case ItemPositionLeft:
4384       m_valueID = CSSValueLeft;
4385       break;
4386     case ItemPositionRight:
4387       m_valueID = CSSValueRight;
4388       break;
4389   }
4390 }
4391
4392 template <>
4393 inline ItemPosition CSSIdentifierValue::convertTo() const {
4394   switch (m_valueID) {
4395     case CSSValueAuto:
4396       return ItemPositionAuto;
4397     case CSSValueNormal:
4398       return ItemPositionNormal;
4399     case CSSValueStretch:
4400       return ItemPositionStretch;
4401     case CSSValueBaseline:
4402       return ItemPositionBaseline;
4403     case CSSValueLastBaseline:
4404       return ItemPositionLastBaseline;
4405     case CSSValueCenter:
4406       return ItemPositionCenter;
4407     case CSSValueStart:
4408       return ItemPositionStart;
4409     case CSSValueEnd:
4410       return ItemPositionEnd;
4411     case CSSValueSelfStart:
4412       return ItemPositionSelfStart;
4413     case CSSValueSelfEnd:
4414       return ItemPositionSelfEnd;
4415     case CSSValueFlexStart:
4416       return ItemPositionFlexStart;
4417     case CSSValueFlexEnd:
4418       return ItemPositionFlexEnd;
4419     case CSSValueLeft:
4420       return ItemPositionLeft;
4421     case CSSValueRight:
4422       return ItemPositionRight;
4423     default:
4424       break;
4425   }
4426   ASSERT_NOT_REACHED();
4427   return ItemPositionAuto;
4428 }
4429
4430 template <>
4431 inline CSSIdentifierValue::CSSIdentifierValue(ContentPosition contentPosition)
4432     : CSSValue(IdentifierClass) {
4433   switch (contentPosition) {
4434     case ContentPositionNormal:
4435       m_valueID = CSSValueNormal;
4436       break;
4437     case ContentPositionBaseline:
4438       m_valueID = CSSValueBaseline;
4439       break;
4440     case ContentPositionLastBaseline:
4441       m_valueID = CSSValueLastBaseline;
4442       break;
4443     case ContentPositionCenter:
4444       m_valueID = CSSValueCenter;
4445       break;
4446     case ContentPositionStart:
4447       m_valueID = CSSValueStart;
4448       break;
4449     case ContentPositionEnd:
4450       m_valueID = CSSValueEnd;
4451       break;
4452     case ContentPositionFlexStart:
4453       m_valueID = CSSValueFlexStart;
4454       break;
4455     case ContentPositionFlexEnd:
4456       m_valueID = CSSValueFlexEnd;
4457       break;
4458     case ContentPositionLeft:
4459       m_valueID = CSSValueLeft;
4460       break;
4461     case ContentPositionRight:
4462       m_valueID = CSSValueRight;
4463       break;
4464   }
4465 }
4466
4467 template <>
4468 inline ContentPosition CSSIdentifierValue::convertTo() const {
4469   switch (m_valueID) {
4470     case CSSValueNormal:
4471       return ContentPositionNormal;
4472     case CSSValueBaseline:
4473       return ContentPositionBaseline;
4474     case CSSValueLastBaseline:
4475       return ContentPositionLastBaseline;
4476     case CSSValueCenter:
4477       return ContentPositionCenter;
4478     case CSSValueStart:
4479       return ContentPositionStart;
4480     case CSSValueEnd:
4481       return ContentPositionEnd;
4482     case CSSValueFlexStart:
4483       return ContentPositionFlexStart;
4484     case CSSValueFlexEnd:
4485       return ContentPositionFlexEnd;
4486     case CSSValueLeft:
4487       return ContentPositionLeft;
4488     case CSSValueRight:
4489       return ContentPositionRight;
4490     default:
4491       break;
4492   }
4493   ASSERT_NOT_REACHED();
4494   return ContentPositionNormal;
4495 }
4496
4497 template <>
4498 inline CSSIdentifierValue::CSSIdentifierValue(
4499     ContentDistributionType contentDistribution)
4500     : CSSValue(IdentifierClass) {
4501   switch (contentDistribution) {
4502     case ContentDistributionDefault:
4503       m_valueID = CSSValueDefault;
4504       break;
4505     case ContentDistributionSpaceBetween:
4506       m_valueID = CSSValueSpaceBetween;
4507       break;
4508     case ContentDistributionSpaceAround:
4509       m_valueID = CSSValueSpaceAround;
4510       break;
4511     case ContentDistributionSpaceEvenly:
4512       m_valueID = CSSValueSpaceEvenly;
4513       break;
4514     case ContentDistributionStretch:
4515       m_valueID = CSSValueStretch;
4516       break;
4517   }
4518 }
4519
4520 template <>
4521 inline ContentDistributionType CSSIdentifierValue::convertTo() const {
4522   switch (m_valueID) {
4523     case CSSValueSpaceBetween:
4524       return ContentDistributionSpaceBetween;
4525     case CSSValueSpaceAround:
4526       return ContentDistributionSpaceAround;
4527     case CSSValueSpaceEvenly:
4528       return ContentDistributionSpaceEvenly;
4529     case CSSValueStretch:
4530       return ContentDistributionStretch;
4531     default:
4532       break;
4533   }
4534   ASSERT_NOT_REACHED();
4535   return ContentDistributionStretch;
4536 }
4537
4538 template <>
4539 inline CSSIdentifierValue::CSSIdentifierValue(
4540     OverflowAlignment overflowAlignment)
4541     : CSSValue(IdentifierClass) {
4542   switch (overflowAlignment) {
4543     case OverflowAlignmentDefault:
4544       m_valueID = CSSValueDefault;
4545       break;
4546     case OverflowAlignmentUnsafe:
4547       m_valueID = CSSValueUnsafe;
4548       break;
4549     case OverflowAlignmentSafe:
4550       m_valueID = CSSValueSafe;
4551       break;
4552   }
4553 }
4554
4555 template <>
4556 inline OverflowAlignment CSSIdentifierValue::convertTo() const {
4557   switch (m_valueID) {
4558     case CSSValueUnsafe:
4559       return OverflowAlignmentUnsafe;
4560     case CSSValueSafe:
4561       return OverflowAlignmentSafe;
4562     default:
4563       break;
4564   }
4565   ASSERT_NOT_REACHED();
4566   return OverflowAlignmentUnsafe;
4567 }
4568
4569 template <>
4570 inline CSSIdentifierValue::CSSIdentifierValue(ScrollBehavior behavior)
4571     : CSSValue(IdentifierClass) {
4572   switch (behavior) {
4573     case ScrollBehaviorAuto:
4574       m_valueID = CSSValueAuto;
4575       break;
4576     case ScrollBehaviorSmooth:
4577       m_valueID = CSSValueSmooth;
4578       break;
4579     case ScrollBehaviorInstant:
4580       // Behavior 'instant' is only allowed in ScrollOptions arguments passed to
4581       // CSSOM scroll APIs.
4582       ASSERT_NOT_REACHED();
4583   }
4584 }
4585
4586 template <>
4587 inline ScrollBehavior CSSIdentifierValue::convertTo() const {
4588   switch (getValueID()) {
4589     case CSSValueAuto:
4590       return ScrollBehaviorAuto;
4591     case CSSValueSmooth:
4592       return ScrollBehaviorSmooth;
4593     default:
4594       break;
4595   }
4596   ASSERT_NOT_REACHED();
4597   return ScrollBehaviorAuto;
4598 }
4599
4600 template <>
4601 inline CSSIdentifierValue::CSSIdentifierValue(ScrollSnapType snapType)
4602     : CSSValue(IdentifierClass) {
4603   switch (snapType) {
4604     case ScrollSnapTypeNone:
4605       m_valueID = CSSValueNone;
4606       break;
4607     case ScrollSnapTypeMandatory:
4608       m_valueID = CSSValueMandatory;
4609       break;
4610     case ScrollSnapTypeProximity:
4611       m_valueID = CSSValueProximity;
4612       break;
4613   }
4614 }
4615
4616 template <>
4617 inline ScrollSnapType CSSIdentifierValue::convertTo() const {
4618   switch (getValueID()) {
4619     case CSSValueNone:
4620       return ScrollSnapTypeNone;
4621     case CSSValueMandatory:
4622       return ScrollSnapTypeMandatory;
4623     case CSSValueProximity:
4624       return ScrollSnapTypeProximity;
4625     default:
4626       break;
4627   }
4628   ASSERT_NOT_REACHED();
4629   return ScrollSnapTypeNone;
4630 }
4631
4632 template <>
4633 inline CSSIdentifierValue::CSSIdentifierValue(Containment snapType)
4634     : CSSValue(IdentifierClass) {
4635   switch (snapType) {
4636     case ContainsNone:
4637       m_valueID = CSSValueNone;
4638       break;
4639     case ContainsStrict:
4640       m_valueID = CSSValueStrict;
4641       break;
4642     case ContainsContent:
4643       m_valueID = CSSValueContent;
4644       break;
4645     case ContainsPaint:
4646       m_valueID = CSSValuePaint;
4647       break;
4648     case ContainsStyle:
4649       m_valueID = CSSValueStyle;
4650       break;
4651     case ContainsLayout:
4652       m_valueID = CSSValueLayout;
4653       break;
4654     case ContainsSize:
4655       m_valueID = CSSValueSize;
4656       break;
4657   }
4658 }
4659
4660 template <>
4661 inline Containment CSSIdentifierValue::convertTo() const {
4662   switch (getValueID()) {
4663     case CSSValueNone:
4664       return ContainsNone;
4665     case CSSValueStrict:
4666       return ContainsStrict;
4667     case CSSValueContent:
4668       return ContainsContent;
4669     case CSSValuePaint:
4670       return ContainsPaint;
4671     case CSSValueStyle:
4672       return ContainsStyle;
4673     case CSSValueLayout:
4674       return ContainsLayout;
4675     case CSSValueSize:
4676       return ContainsSize;
4677     default:
4678       break;
4679   }
4680   ASSERT_NOT_REACHED();
4681   return ContainsNone;
4682 }
4683
4684 }  // namespace blink
4685
4686 #endif