src/third_party/WebKit/Source/core/css/CSSPrimitiveValueMappings.h

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