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