Source/WebCore/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 #pragma once
  31
  32 #include "CSSCalculationValue.h"
  33 #include "CSSFontFamily.h"
  34 #include "CSSPrimitiveValue.h"
  35 #include "CSSReflectionDirection.h"
  36 #include "CSSToLengthConversionData.h"
  37 #include "CSSValueKeywords.h"
  38 #include "GraphicsTypes.h"
  39 #include "Length.h"
  40 #include "LineClampValue.h"
  41 #include "RenderStyleConstants.h"
  42 #include "SVGRenderStyleDefs.h"
  43 #include "TextFlags.h"
  44 #include "ThemeTypes.h"
  45 #include "UnicodeBidi.h"
  46 #include "WritingMode.h"
  47 #include <wtf/MathExtras.h>
  48
  49 #if ENABLE(CSS_IMAGE_ORIENTATION)
  50 #include "ImageOrientation.h"
  51 #endif
  52
  53 namespace WebCore {
  54
  55 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(short i)
  56     : CSSValue(PrimitiveClass)
  57 {
  58     m_primitiveUnitType = CSS_NUMBER;
  59     m_value.num = static_cast<double>(i);
  60 }
  61
  62 template<> inline CSSPrimitiveValue::operator short() const
  63 {
  64     if (m_primitiveUnitType == CSS_NUMBER)
  65         return clampTo<short>(m_value.num);
  66
  67     ASSERT_NOT_REACHED();
  68     return 0;
  69 }
  70
  71 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(unsigned short i)
  72     : CSSValue(PrimitiveClass)
  73 {
  74     m_primitiveUnitType = CSS_NUMBER;
  75     m_value.num = static_cast<double>(i);
  76 }
  77
  78 template<> inline CSSPrimitiveValue::operator unsigned short() const
  79 {
  80     if (primitiveType() == CSS_NUMBER)
  81         return value<unsigned short>();
  82
  83     ASSERT_NOT_REACHED();
  84     return 0;
  85 }
  86
  87 template<> inline CSSPrimitiveValue::operator int() const
  88 {
  89     if (primitiveType() == CSS_NUMBER)
  90         return value<int>();
  91
  92     ASSERT_NOT_REACHED();
  93     return 0;
  94 }
  95
  96 template<> inline CSSPrimitiveValue::operator unsigned() const
  97 {
  98     if (primitiveType() == CSS_NUMBER)
  99         return value<unsigned>();
 100
 101     ASSERT_NOT_REACHED();
 102     return 0;
 103 }
 104
 105
 106 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(float i)
 107     : CSSValue(PrimitiveClass)
 108 {
 109     m_primitiveUnitType = CSS_NUMBER;
 110     m_value.num = static_cast<double>(i);
 111 }
 112
 113 template<> inline CSSPrimitiveValue::operator float() const
 114 {
 115     if (primitiveType() == CSS_NUMBER)
 116         return value<float>();
 117
 118     ASSERT_NOT_REACHED();
 119     return 0.0f;
 120 }
 121
 122 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineClampValue i)
 123     : CSSValue(PrimitiveClass)
 124 {
 125     m_primitiveUnitType = i.isPercentage() ? CSS_PERCENTAGE : CSS_NUMBER;
 126     m_value.num = static_cast<double>(i.value());
 127 }
 128
 129 template<> inline CSSPrimitiveValue::operator LineClampValue() const
 130 {
 131     if (primitiveType() == CSS_NUMBER)
 132         return LineClampValue(value<int>(), LineClampLineCount);
 133
 134     if (primitiveType() == CSS_PERCENTAGE)
 135         return LineClampValue(value<int>(), LineClampPercentage);
 136
 137     ASSERT_NOT_REACHED();
 138     return LineClampValue();
 139 }
 140
 141 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(CSSReflectionDirection e)
 142     : CSSValue(PrimitiveClass)
 143 {
 144     m_primitiveUnitType = CSS_VALUE_ID;
 145     switch (e) {
 146     case ReflectionAbove:
 147         m_value.valueID = CSSValueAbove;
 148         break;
 149     case ReflectionBelow:
 150         m_value.valueID = CSSValueBelow;
 151         break;
 152     case ReflectionLeft:
 153         m_value.valueID = CSSValueLeft;
 154         break;
 155     case ReflectionRight:
 156         m_value.valueID = CSSValueRight;
 157     }
 158 }
 159
 160 template<> inline CSSPrimitiveValue::operator CSSReflectionDirection() const
 161 {
 162     ASSERT(isValueID());
 163
 164     switch (m_value.valueID) {
 165     case CSSValueAbove:
 166         return ReflectionAbove;
 167     case CSSValueBelow:
 168         return ReflectionBelow;
 169     case CSSValueLeft:
 170         return ReflectionLeft;
 171     case CSSValueRight:
 172         return ReflectionRight;
 173     default:
 174         break;
 175     }
 176
 177     ASSERT_NOT_REACHED();
 178     return ReflectionBelow;
 179 }
 180
 181 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ColumnFill columnFill)
 182     : CSSValue(PrimitiveClass)
 183 {
 184     m_primitiveUnitType = CSS_VALUE_ID;
 185     switch (columnFill) {
 186     case ColumnFillAuto:
 187         m_value.valueID = CSSValueAuto;
 188         break;
 189     case ColumnFillBalance:
 190         m_value.valueID = CSSValueBalance;
 191         break;
 192     }
 193 }
 194
 195 template<> inline CSSPrimitiveValue::operator ColumnFill() const
 196 {
 197     if (m_primitiveUnitType == CSS_VALUE_ID) {
 198         if (m_value.valueID == CSSValueBalance)
 199             return ColumnFillBalance;
 200         if (m_value.valueID == CSSValueAuto)
 201             return ColumnFillAuto;
 202     }
 203     ASSERT_NOT_REACHED();
 204     return ColumnFillBalance;
 205 }
 206
 207 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ColumnSpan columnSpan)
 208     : CSSValue(PrimitiveClass)
 209 {
 210     m_primitiveUnitType = CSS_VALUE_ID;
 211     switch (columnSpan) {
 212     case ColumnSpanAll:
 213         m_value.valueID = CSSValueAll;
 214         break;
 215     case ColumnSpanNone:
 216         m_value.valueID = CSSValueNone;
 217         break;
 218     }
 219 }
 220
 221 template<> inline CSSPrimitiveValue::operator ColumnSpan() const
 222 {
 223     // Map 1 to none for compatibility reasons.
 224     if (m_primitiveUnitType == CSS_NUMBER && m_value.num == 1)
 225         return ColumnSpanNone;
 226
 227     ASSERT(isValueID());
 228
 229     switch (m_value.valueID) {
 230     case CSSValueAll:
 231         return ColumnSpanAll;
 232     case CSSValueNone:
 233         return ColumnSpanNone;
 234     default:
 235         break;
 236     }
 237
 238     ASSERT_NOT_REACHED();
 239     return ColumnSpanNone;
 240 }
 241
 242
 243 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(PrintColorAdjust value)
 244     : CSSValue(PrimitiveClass)
 245 {
 246     m_primitiveUnitType = CSS_VALUE_ID;
 247     switch (value) {
 248     case PrintColorAdjustExact:
 249         m_value.valueID = CSSValueExact;
 250         break;
 251     case PrintColorAdjustEconomy:
 252         m_value.valueID = CSSValueEconomy;
 253         break;
 254     }
 255 }
 256
 257 template<> inline CSSPrimitiveValue::operator PrintColorAdjust() const
 258 {
 259     ASSERT(isValueID());
 260
 261     switch (m_value.valueID) {
 262     case CSSValueEconomy:
 263         return PrintColorAdjustEconomy;
 264     case CSSValueExact:
 265         return PrintColorAdjustExact;
 266     default:
 267         break;
 268     }
 269
 270     ASSERT_NOT_REACHED();
 271     return PrintColorAdjustEconomy;
 272 }
 273
 274
 275 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBorderStyle e)
 276     : CSSValue(PrimitiveClass)
 277 {
 278     m_primitiveUnitType = CSS_VALUE_ID;
 279     switch (e) {
 280     case BNONE:
 281         m_value.valueID = CSSValueNone;
 282         break;
 283     case BHIDDEN:
 284         m_value.valueID = CSSValueHidden;
 285         break;
 286     case INSET:
 287         m_value.valueID = CSSValueInset;
 288         break;
 289     case GROOVE:
 290         m_value.valueID = CSSValueGroove;
 291         break;
 292     case RIDGE:
 293         m_value.valueID = CSSValueRidge;
 294         break;
 295     case OUTSET:
 296         m_value.valueID = CSSValueOutset;
 297         break;
 298     case DOTTED:
 299         m_value.valueID = CSSValueDotted;
 300         break;
 301     case DASHED:
 302         m_value.valueID = CSSValueDashed;
 303         break;
 304     case SOLID:
 305         m_value.valueID = CSSValueSolid;
 306         break;
 307     case DOUBLE:
 308         m_value.valueID = CSSValueDouble;
 309         break;
 310     }
 311 }
 312
 313 template<> inline CSSPrimitiveValue::operator EBorderStyle() const
 314 {
 315     ASSERT(isValueID());
 316
 317     if (m_value.valueID == CSSValueAuto) // Valid for CSS outline-style
 318         return DOTTED;
 319     return (EBorderStyle)(m_value.valueID - CSSValueNone);
 320 }
 321
 322 template<> inline CSSPrimitiveValue::operator OutlineIsAuto() const
 323 {
 324     ASSERT(isValueID());
 325
 326     if (m_value.valueID == CSSValueAuto)
 327         return AUTO_ON;
 328     return AUTO_OFF;
 329 }
 330
 331 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(CompositeOperator e)
 332     : CSSValue(PrimitiveClass)
 333 {
 334     m_primitiveUnitType = CSS_VALUE_ID;
 335     switch (e) {
 336     case CompositeClear:
 337         m_value.valueID = CSSValueClear;
 338         break;
 339     case CompositeCopy:
 340         m_value.valueID = CSSValueCopy;
 341         break;
 342     case CompositeSourceOver:
 343         m_value.valueID = CSSValueSourceOver;
 344         break;
 345     case CompositeSourceIn:
 346         m_value.valueID = CSSValueSourceIn;
 347         break;
 348     case CompositeSourceOut:
 349         m_value.valueID = CSSValueSourceOut;
 350         break;
 351     case CompositeSourceAtop:
 352         m_value.valueID = CSSValueSourceAtop;
 353         break;
 354     case CompositeDestinationOver:
 355         m_value.valueID = CSSValueDestinationOver;
 356         break;
 357     case CompositeDestinationIn:
 358         m_value.valueID = CSSValueDestinationIn;
 359         break;
 360     case CompositeDestinationOut:
 361         m_value.valueID = CSSValueDestinationOut;
 362         break;
 363     case CompositeDestinationAtop:
 364         m_value.valueID = CSSValueDestinationAtop;
 365         break;
 366     case CompositeXOR:
 367         m_value.valueID = CSSValueXor;
 368         break;
 369     case CompositePlusDarker:
 370         m_value.valueID = CSSValuePlusDarker;
 371         break;
 372     case CompositePlusLighter:
 373         m_value.valueID = CSSValuePlusLighter;
 374         break;
 375     case CompositeDifference:
 376         ASSERT_NOT_REACHED();
 377         break;
 378     }
 379 }
 380
 381 template<> inline CSSPrimitiveValue::operator CompositeOperator() const
 382 {
 383     ASSERT(isValueID());
 384
 385     switch (m_value.valueID) {
 386     case CSSValueClear:
 387         return CompositeClear;
 388     case CSSValueCopy:
 389         return CompositeCopy;
 390     case CSSValueSourceOver:
 391         return CompositeSourceOver;
 392     case CSSValueSourceIn:
 393         return CompositeSourceIn;
 394     case CSSValueSourceOut:
 395         return CompositeSourceOut;
 396     case CSSValueSourceAtop:
 397         return CompositeSourceAtop;
 398     case CSSValueDestinationOver:
 399         return CompositeDestinationOver;
 400     case CSSValueDestinationIn:
 401         return CompositeDestinationIn;
 402     case CSSValueDestinationOut:
 403         return CompositeDestinationOut;
 404     case CSSValueDestinationAtop:
 405         return CompositeDestinationAtop;
 406     case CSSValueXor:
 407         return CompositeXOR;
 408     case CSSValuePlusDarker:
 409         return CompositePlusDarker;
 410     case CSSValuePlusLighter:
 411         return CompositePlusLighter;
 412     default:
 413         break;
 414     }
 415
 416     ASSERT_NOT_REACHED();
 417     return CompositeClear;
 418 }
 419
 420 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ControlPart e)
 421     : CSSValue(PrimitiveClass)
 422 {
 423     m_primitiveUnitType = CSS_VALUE_ID;
 424     switch (e) {
 425     case NoControlPart:
 426         m_value.valueID = CSSValueNone;
 427         break;
 428     case CheckboxPart:
 429         m_value.valueID = CSSValueCheckbox;
 430         break;
 431     case RadioPart:
 432         m_value.valueID = CSSValueRadio;
 433         break;
 434     case PushButtonPart:
 435         m_value.valueID = CSSValuePushButton;
 436         break;
 437     case SquareButtonPart:
 438         m_value.valueID = CSSValueSquareButton;
 439         break;
 440     case ButtonPart:
 441         m_value.valueID = CSSValueButton;
 442         break;
 443     case ButtonBevelPart:
 444         m_value.valueID = CSSValueButtonBevel;
 445         break;
 446     case DefaultButtonPart:
 447         m_value.valueID = CSSValueDefaultButton;
 448         break;
 449     case InnerSpinButtonPart:
 450         m_value.valueID = CSSValueInnerSpinButton;
 451         break;
 452     case ListboxPart:
 453         m_value.valueID = CSSValueListbox;
 454         break;
 455     case ListItemPart:
 456         m_value.valueID = CSSValueListitem;
 457         break;
 458     case MediaEnterFullscreenButtonPart:
 459         m_value.valueID = CSSValueMediaEnterFullscreenButton;
 460         break;
 461     case MediaExitFullscreenButtonPart:
 462         m_value.valueID = CSSValueMediaExitFullscreenButton;
 463         break;
 464     case MediaPlayButtonPart:
 465         m_value.valueID = CSSValueMediaPlayButton;
 466         break;
 467     case MediaOverlayPlayButtonPart:
 468         m_value.valueID = CSSValueMediaOverlayPlayButton;
 469         break;
 470     case MediaMuteButtonPart:
 471         m_value.valueID = CSSValueMediaMuteButton;
 472         break;
 473     case MediaSeekBackButtonPart:
 474         m_value.valueID = CSSValueMediaSeekBackButton;
 475         break;
 476     case MediaSeekForwardButtonPart:
 477         m_value.valueID = CSSValueMediaSeekForwardButton;
 478         break;
 479     case MediaRewindButtonPart:
 480         m_value.valueID = CSSValueMediaRewindButton;
 481         break;
 482     case MediaReturnToRealtimeButtonPart:
 483         m_value.valueID = CSSValueMediaReturnToRealtimeButton;
 484         break;
 485     case MediaToggleClosedCaptionsButtonPart:
 486         m_value.valueID = CSSValueMediaToggleClosedCaptionsButton;
 487         break;
 488     case MediaSliderPart:
 489         m_value.valueID = CSSValueMediaSlider;
 490         break;
 491     case MediaSliderThumbPart:
 492         m_value.valueID = CSSValueMediaSliderthumb;
 493         break;
 494     case MediaVolumeSliderContainerPart:
 495         m_value.valueID = CSSValueMediaVolumeSliderContainer;
 496         break;
 497     case MediaVolumeSliderPart:
 498         m_value.valueID = CSSValueMediaVolumeSlider;
 499         break;
 500     case MediaVolumeSliderMuteButtonPart:
 501         m_value.valueID = CSSValueMediaVolumeSliderMuteButton;
 502         break;
 503     case MediaVolumeSliderThumbPart:
 504         m_value.valueID = CSSValueMediaVolumeSliderthumb;
 505         break;
 506     case MediaControlsBackgroundPart:
 507         m_value.valueID = CSSValueMediaControlsBackground;
 508         break;
 509     case MediaControlsFullscreenBackgroundPart:
 510         m_value.valueID = CSSValueMediaControlsFullscreenBackground;
 511         break;
 512     case MediaFullScreenVolumeSliderPart:
 513         m_value.valueID = CSSValueMediaFullscreenVolumeSlider;
 514         break;
 515     case MediaFullScreenVolumeSliderThumbPart:
 516         m_value.valueID = CSSValueMediaFullscreenVolumeSliderThumb;
 517         break;
 518     case MediaCurrentTimePart:
 519         m_value.valueID = CSSValueMediaCurrentTimeDisplay;
 520         break;
 521     case MediaTimeRemainingPart:
 522         m_value.valueID = CSSValueMediaTimeRemainingDisplay;
 523         break;
 524     case MediaControlsLightBarBackgroundPart:
 525         m_value.valueID = CSSValueMediaControlsLightBarBackground;
 526         break;
 527     case MediaControlsDarkBarBackgroundPart:
 528         m_value.valueID = CSSValueMediaControlsDarkBarBackground;
 529         break;
 530     case MenulistPart:
 531         m_value.valueID = CSSValueMenulist;
 532         break;
 533     case MenulistButtonPart:
 534         m_value.valueID = CSSValueMenulistButton;
 535         break;
 536     case MenulistTextPart:
 537         m_value.valueID = CSSValueMenulistText;
 538         break;
 539     case MenulistTextFieldPart:
 540         m_value.valueID = CSSValueMenulistTextfield;
 541         break;
 542     case MeterPart:
 543         m_value.valueID = CSSValueMeter;
 544         break;
 545     case RelevancyLevelIndicatorPart:
 546         m_value.valueID = CSSValueRelevancyLevelIndicator;
 547         break;
 548     case ContinuousCapacityLevelIndicatorPart:
 549         m_value.valueID = CSSValueContinuousCapacityLevelIndicator;
 550         break;
 551     case DiscreteCapacityLevelIndicatorPart:
 552         m_value.valueID = CSSValueDiscreteCapacityLevelIndicator;
 553         break;
 554     case RatingLevelIndicatorPart:
 555         m_value.valueID = CSSValueRatingLevelIndicator;
 556         break;
 557     case ProgressBarPart:
 558         m_value.valueID = CSSValueProgressBar;
 559         break;
 560     case ProgressBarValuePart:
 561         m_value.valueID = CSSValueProgressBarValue;
 562         break;
 563     case SliderHorizontalPart:
 564         m_value.valueID = CSSValueSliderHorizontal;
 565         break;
 566     case SliderVerticalPart:
 567         m_value.valueID = CSSValueSliderVertical;
 568         break;
 569     case SliderThumbHorizontalPart:
 570         m_value.valueID = CSSValueSliderthumbHorizontal;
 571         break;
 572     case SliderThumbVerticalPart:
 573         m_value.valueID = CSSValueSliderthumbVertical;
 574         break;
 575     case CaretPart:
 576         m_value.valueID = CSSValueCaret;
 577         break;
 578     case SearchFieldPart:
 579         m_value.valueID = CSSValueSearchfield;
 580         break;
 581     case SearchFieldDecorationPart:
 582         m_value.valueID = CSSValueSearchfieldDecoration;
 583         break;
 584     case SearchFieldResultsDecorationPart:
 585         m_value.valueID = CSSValueSearchfieldResultsDecoration;
 586         break;
 587     case SearchFieldResultsButtonPart:
 588         m_value.valueID = CSSValueSearchfieldResultsButton;
 589         break;
 590     case SearchFieldCancelButtonPart:
 591         m_value.valueID = CSSValueSearchfieldCancelButton;
 592         break;
 593     case SnapshottedPluginOverlayPart:
 594         m_value.valueID = CSSValueSnapshottedPluginOverlay;
 595         break;
 596     case TextFieldPart:
 597         m_value.valueID = CSSValueTextfield;
 598         break;
 599     case TextAreaPart:
 600         m_value.valueID = CSSValueTextarea;
 601         break;
 602     case CapsLockIndicatorPart:
 603         m_value.valueID = CSSValueCapsLockIndicator;
 604         break;
 605 #if ENABLE(ATTACHMENT_ELEMENT)
 606     case AttachmentPart:
 607         m_value.valueID = CSSValueAttachment;
 608         break;
 609     case BorderlessAttachmentPart:
 610         m_value.valueID = CSSValueBorderlessAttachment;
 611         break;
 612 #endif
 613 #if ENABLE(SERVICE_CONTROLS)
 614     case ImageControlsButtonPart:
 615         m_value.valueID = CSSValueImageControlsButton;
 616         break;
 617 #endif
 618 #if ENABLE(APPLE_PAY)
 619     case ApplePayButtonPart:
 620         m_value.valueID = CSSValueApplePayButton;
 621         break;
 622 #endif
 623     }
 624 }
 625
 626 template<> inline CSSPrimitiveValue::operator ControlPart() const
 627 {
 628     ASSERT(isValueID());
 629
 630     if (m_value.valueID == CSSValueNone)
 631         return NoControlPart;
 632     return ControlPart(m_value.valueID - CSSValueCheckbox + 1);
 633 }
 634
 635 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBackfaceVisibility e)
 636     : CSSValue(PrimitiveClass)
 637 {
 638     m_primitiveUnitType = CSS_VALUE_ID;
 639     switch (e) {
 640     case BackfaceVisibilityVisible:
 641         m_value.valueID = CSSValueVisible;
 642         break;
 643     case BackfaceVisibilityHidden:
 644         m_value.valueID = CSSValueHidden;
 645         break;
 646     }
 647 }
 648
 649 template<> inline CSSPrimitiveValue::operator EBackfaceVisibility() const
 650 {
 651     ASSERT(isValueID());
 652
 653     switch (m_value.valueID) {
 654     case CSSValueVisible:
 655         return BackfaceVisibilityVisible;
 656     case CSSValueHidden:
 657         return BackfaceVisibilityHidden;
 658     default:
 659         break;
 660     }
 661
 662     ASSERT_NOT_REACHED();
 663     return BackfaceVisibilityHidden;
 664 }
 665
 666
 667 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFillAttachment e)
 668     : CSSValue(PrimitiveClass)
 669 {
 670     m_primitiveUnitType = CSS_VALUE_ID;
 671     switch (e) {
 672     case ScrollBackgroundAttachment:
 673         m_value.valueID = CSSValueScroll;
 674         break;
 675     case LocalBackgroundAttachment:
 676         m_value.valueID = CSSValueLocal;
 677         break;
 678     case FixedBackgroundAttachment:
 679         m_value.valueID = CSSValueFixed;
 680         break;
 681     }
 682 }
 683
 684 template<> inline CSSPrimitiveValue::operator EFillAttachment() const
 685 {
 686     ASSERT(isValueID());
 687
 688     switch (m_value.valueID) {
 689     case CSSValueScroll:
 690         return ScrollBackgroundAttachment;
 691     case CSSValueLocal:
 692         return LocalBackgroundAttachment;
 693     case CSSValueFixed:
 694         return FixedBackgroundAttachment;
 695     default:
 696         break;
 697     }
 698
 699     ASSERT_NOT_REACHED();
 700     return ScrollBackgroundAttachment;
 701 }
 702
 703 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFillBox e)
 704     : CSSValue(PrimitiveClass)
 705 {
 706     m_primitiveUnitType = CSS_VALUE_ID;
 707     switch (e) {
 708     case BorderFillBox:
 709         m_value.valueID = CSSValueBorderBox;
 710         break;
 711     case PaddingFillBox:
 712         m_value.valueID = CSSValuePaddingBox;
 713         break;
 714     case ContentFillBox:
 715         m_value.valueID = CSSValueContentBox;
 716         break;
 717     case TextFillBox:
 718         m_value.valueID = CSSValueText;
 719         break;
 720     }
 721 }
 722
 723 template<> inline CSSPrimitiveValue::operator EFillBox() const
 724 {
 725     ASSERT(isValueID());
 726
 727     switch (m_value.valueID) {
 728     case CSSValueBorder:
 729     case CSSValueBorderBox:
 730         return BorderFillBox;
 731     case CSSValuePadding:
 732     case CSSValuePaddingBox:
 733         return PaddingFillBox;
 734     case CSSValueContent:
 735     case CSSValueContentBox:
 736         return ContentFillBox;
 737     case CSSValueText:
 738     case CSSValueWebkitText:
 739         return TextFillBox;
 740     default:
 741         break;
 742     }
 743
 744     ASSERT_NOT_REACHED();
 745     return BorderFillBox;
 746 }
 747
 748 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFillRepeat e)
 749     : CSSValue(PrimitiveClass)
 750 {
 751     m_primitiveUnitType = CSS_VALUE_ID;
 752     switch (e) {
 753     case RepeatFill:
 754         m_value.valueID = CSSValueRepeat;
 755         break;
 756     case NoRepeatFill:
 757         m_value.valueID = CSSValueNoRepeat;
 758         break;
 759     case RoundFill:
 760         m_value.valueID = CSSValueRound;
 761         break;
 762     case SpaceFill:
 763         m_value.valueID = CSSValueSpace;
 764         break;
 765     }
 766 }
 767
 768 template<> inline CSSPrimitiveValue::operator EFillRepeat() const
 769 {
 770     ASSERT(isValueID());
 771
 772     switch (m_value.valueID) {
 773     case CSSValueRepeat:
 774         return RepeatFill;
 775     case CSSValueNoRepeat:
 776         return NoRepeatFill;
 777     case CSSValueRound:
 778         return RoundFill;
 779     case CSSValueSpace:
 780         return SpaceFill;
 781     default:
 782         break;
 783     }
 784
 785     ASSERT_NOT_REACHED();
 786     return RepeatFill;
 787 }
 788
 789 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxPack e)
 790     : CSSValue(PrimitiveClass)
 791 {
 792     m_primitiveUnitType = CSS_VALUE_ID;
 793     switch (e) {
 794     case Start:
 795         m_value.valueID = CSSValueStart;
 796         break;
 797     case Center:
 798         m_value.valueID = CSSValueCenter;
 799         break;
 800     case End:
 801         m_value.valueID = CSSValueEnd;
 802         break;
 803     case Justify:
 804         m_value.valueID = CSSValueJustify;
 805         break;
 806     }
 807 }
 808
 809 template<> inline CSSPrimitiveValue::operator EBoxPack() const
 810 {
 811     ASSERT(isValueID());
 812
 813     switch (m_value.valueID) {
 814     case CSSValueStart:
 815         return Start;
 816     case CSSValueEnd:
 817         return End;
 818     case CSSValueCenter:
 819         return Center;
 820     case CSSValueJustify:
 821         return Justify;
 822     default:
 823         break;
 824     }
 825
 826     ASSERT_NOT_REACHED();
 827     return Justify;
 828 }
 829
 830 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxAlignment e)
 831     : CSSValue(PrimitiveClass)
 832 {
 833     m_primitiveUnitType = CSS_VALUE_ID;
 834     switch (e) {
 835     case BSTRETCH:
 836         m_value.valueID = CSSValueStretch;
 837         break;
 838     case BSTART:
 839         m_value.valueID = CSSValueStart;
 840         break;
 841     case BCENTER:
 842         m_value.valueID = CSSValueCenter;
 843         break;
 844     case BEND:
 845         m_value.valueID = CSSValueEnd;
 846         break;
 847     case BBASELINE:
 848         m_value.valueID = CSSValueBaseline;
 849         break;
 850     }
 851 }
 852
 853 template<> inline CSSPrimitiveValue::operator EBoxAlignment() const
 854 {
 855     ASSERT(isValueID());
 856
 857     switch (m_value.valueID) {
 858     case CSSValueStretch:
 859         return BSTRETCH;
 860     case CSSValueStart:
 861         return BSTART;
 862     case CSSValueEnd:
 863         return BEND;
 864     case CSSValueCenter:
 865         return BCENTER;
 866     case CSSValueBaseline:
 867         return BBASELINE;
 868     default:
 869         break;
 870     }
 871
 872     ASSERT_NOT_REACHED();
 873     return BSTRETCH;
 874 }
 875
 876 #if ENABLE(CSS_BOX_DECORATION_BREAK)
 877 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxDecorationBreak e)
 878     : CSSValue(PrimitiveClass)
 879 {
 880     m_primitiveUnitType = CSS_VALUE_ID;
 881     switch (e) {
 882     case DSLICE:
 883         m_value.valueID = CSSValueSlice;
 884         break;
 885     case DCLONE:
 886         m_value.valueID = CSSValueClone;
 887         break;
 888     }
 889 }
 890
 891 template<> inline CSSPrimitiveValue::operator EBoxDecorationBreak() const
 892 {
 893     ASSERT(isValueID());
 894
 895     switch (m_value.valueID) {
 896     case CSSValueSlice:
 897         return DSLICE;
 898     case CSSValueClone:
 899         return DCLONE;
 900     default:
 901         break;
 902     }
 903
 904     ASSERT_NOT_REACHED();
 905     return DSLICE;
 906 }
 907 #endif
 908
 909 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(Edge e)
 910     : CSSValue(PrimitiveClass)
 911 {
 912     m_primitiveUnitType = CSS_VALUE_ID;
 913     switch (e) {
 914     case Edge::Top:
 915         m_value.valueID = CSSValueTop;
 916         break;
 917     case Edge::Right:
 918         m_value.valueID = CSSValueRight;
 919         break;
 920     case Edge::Bottom:
 921         m_value.valueID = CSSValueBottom;
 922         break;
 923     case Edge::Left:
 924         m_value.valueID = CSSValueLeft;
 925         break;
 926     }
 927 }
 928
 929 template<> inline CSSPrimitiveValue::operator Edge() const
 930 {
 931     ASSERT(isValueID());
 932
 933     switch (m_value.valueID) {
 934     case CSSValueTop:
 935         return Edge::Top;
 936     case CSSValueRight:
 937         return Edge::Right;
 938     case CSSValueBottom:
 939         return Edge::Bottom;
 940     case CSSValueLeft:
 941         return Edge::Left;
 942     default:
 943         break;
 944     }
 945
 946     ASSERT_NOT_REACHED();
 947     return Edge::Top;
 948 }
 949
 950 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxSizing e)
 951     : CSSValue(PrimitiveClass)
 952 {
 953     m_primitiveUnitType = CSS_VALUE_ID;
 954     switch (e) {
 955     case BORDER_BOX:
 956         m_value.valueID = CSSValueBorderBox;
 957         break;
 958     case CONTENT_BOX:
 959         m_value.valueID = CSSValueContentBox;
 960         break;
 961     }
 962 }
 963
 964 template<> inline CSSPrimitiveValue::operator EBoxSizing() const
 965 {
 966     ASSERT(isValueID());
 967
 968     switch (m_value.valueID) {
 969     case CSSValueBorderBox:
 970         return BORDER_BOX;
 971     case CSSValueContentBox:
 972         return CONTENT_BOX;
 973     default:
 974         break;
 975     }
 976
 977     ASSERT_NOT_REACHED();
 978     return BORDER_BOX;
 979 }
 980
 981 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxDirection e)
 982     : CSSValue(PrimitiveClass)
 983 {
 984     m_primitiveUnitType = CSS_VALUE_ID;
 985     switch (e) {
 986     case BNORMAL:
 987         m_value.valueID = CSSValueNormal;
 988         break;
 989     case BREVERSE:
 990         m_value.valueID = CSSValueReverse;
 991         break;
 992     }
 993 }
 994
 995 template<> inline CSSPrimitiveValue::operator EBoxDirection() const
 996 {
 997     ASSERT(isValueID());
 998
 999     switch (m_value.valueID) {
1000     case CSSValueNormal:
1001         return BNORMAL;
1002     case CSSValueReverse:
1003         return BREVERSE;
1004     default:
1005         break;
1006     }
1007
1008     ASSERT_NOT_REACHED();
1009     return BNORMAL;
1010 }
1011
1012 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxLines e)
1013     : CSSValue(PrimitiveClass)
1014 {
1015     m_primitiveUnitType = CSS_VALUE_ID;
1016     switch (e) {
1017     case SINGLE:
1018         m_value.valueID = CSSValueSingle;
1019         break;
1020     case MULTIPLE:
1021         m_value.valueID = CSSValueMultiple;
1022         break;
1023     }
1024 }
1025
1026 template<> inline CSSPrimitiveValue::operator EBoxLines() const
1027 {
1028     ASSERT(isValueID());
1029
1030     switch (m_value.valueID) {
1031     case CSSValueSingle:
1032         return SINGLE;
1033     case CSSValueMultiple:
1034         return MULTIPLE;
1035     default:
1036         break;
1037     }
1038
1039     ASSERT_NOT_REACHED();
1040     return SINGLE;
1041 }
1042
1043 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxOrient e)
1044     : CSSValue(PrimitiveClass)
1045 {
1046     m_primitiveUnitType = CSS_VALUE_ID;
1047     switch (e) {
1048     case HORIZONTAL:
1049         m_value.valueID = CSSValueHorizontal;
1050         break;
1051     case VERTICAL:
1052         m_value.valueID = CSSValueVertical;
1053         break;
1054     }
1055 }
1056
1057 template<> inline CSSPrimitiveValue::operator EBoxOrient() const
1058 {
1059     ASSERT(isValueID());
1060
1061     switch (m_value.valueID) {
1062     case CSSValueHorizontal:
1063     case CSSValueInlineAxis:
1064         return HORIZONTAL;
1065     case CSSValueVertical:
1066     case CSSValueBlockAxis:
1067         return VERTICAL;
1068     default:
1069         break;
1070     }
1071
1072     ASSERT_NOT_REACHED();
1073     return HORIZONTAL;
1074 }
1075
1076 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ECaptionSide e)
1077     : CSSValue(PrimitiveClass)
1078 {
1079     m_primitiveUnitType = CSS_VALUE_ID;
1080     switch (e) {
1081     case CAPLEFT:
1082         m_value.valueID = CSSValueLeft;
1083         break;
1084     case CAPRIGHT:
1085         m_value.valueID = CSSValueRight;
1086         break;
1087     case CAPTOP:
1088         m_value.valueID = CSSValueTop;
1089         break;
1090     case CAPBOTTOM:
1091         m_value.valueID = CSSValueBottom;
1092         break;
1093     }
1094 }
1095
1096 template<> inline CSSPrimitiveValue::operator ECaptionSide() const
1097 {
1098     ASSERT(isValueID());
1099
1100     switch (m_value.valueID) {
1101     case CSSValueLeft:
1102         return CAPLEFT;
1103     case CSSValueRight:
1104         return CAPRIGHT;
1105     case CSSValueTop:
1106         return CAPTOP;
1107     case CSSValueBottom:
1108         return CAPBOTTOM;
1109     default:
1110         break;
1111     }
1112
1113     ASSERT_NOT_REACHED();
1114     return CAPTOP;
1115 }
1116
1117 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EClear e)
1118     : CSSValue(PrimitiveClass)
1119 {
1120     m_primitiveUnitType = CSS_VALUE_ID;
1121     switch (e) {
1122     case CNONE:
1123         m_value.valueID = CSSValueNone;
1124         break;
1125     case CLEFT:
1126         m_value.valueID = CSSValueLeft;
1127         break;
1128     case CRIGHT:
1129         m_value.valueID = CSSValueRight;
1130         break;
1131     case CBOTH:
1132         m_value.valueID = CSSValueBoth;
1133         break;
1134     }
1135 }
1136
1137 template<> inline CSSPrimitiveValue::operator EClear() const
1138 {
1139     ASSERT(isValueID());
1140
1141     switch (m_value.valueID) {
1142     case CSSValueNone:
1143         return CNONE;
1144     case CSSValueLeft:
1145         return CLEFT;
1146     case CSSValueRight:
1147         return CRIGHT;
1148     case CSSValueBoth:
1149         return CBOTH;
1150     default:
1151         break;
1152     }
1153
1154     ASSERT_NOT_REACHED();
1155     return CNONE;
1156 }
1157
1158 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ECursor e)
1159     : CSSValue(PrimitiveClass)
1160 {
1161     m_primitiveUnitType = CSS_VALUE_ID;
1162     switch (e) {
1163     case CursorAuto:
1164         m_value.valueID = CSSValueAuto;
1165         break;
1166     case CursorDefault:
1167         m_value.valueID = CSSValueDefault;
1168         break;
1169     case CursorNone:
1170         m_value.valueID = CSSValueNone;
1171         break;
1172     case CursorContextMenu:
1173         m_value.valueID = CSSValueContextMenu;
1174         break;
1175     case CursorHelp:
1176         m_value.valueID = CSSValueHelp;
1177         break;
1178     case CursorPointer:
1179         m_value.valueID = CSSValuePointer;
1180         break;
1181     case CursorProgress:
1182         m_value.valueID = CSSValueProgress;
1183         break;
1184     case CursorWait:
1185         m_value.valueID = CSSValueWait;
1186         break;
1187     case CursorCell:
1188         m_value.valueID = CSSValueCell;
1189         break;
1190     case CursorCrosshair:
1191         m_value.valueID = CSSValueCrosshair;
1192         break;
1193     case CursorText:
1194         m_value.valueID = CSSValueText;
1195         break;
1196     case CursorVerticalText:
1197         m_value.valueID = CSSValueVerticalText;
1198         break;
1199     case CursorAlias:
1200         m_value.valueID = CSSValueAlias;
1201         break;
1202     case CursorCopy:
1203         m_value.valueID = CSSValueCopy;
1204         break;
1205     case CursorMove:
1206         m_value.valueID = CSSValueMove;
1207         break;
1208     case CursorNoDrop:
1209         m_value.valueID = CSSValueNoDrop;
1210         break;
1211     case CursorNotAllowed:
1212         m_value.valueID = CSSValueNotAllowed;
1213         break;
1214     case CursorGrab:
1215         m_value.valueID = CSSValueGrab;
1216         break;
1217     case CursorGrabbing:
1218         m_value.valueID = CSSValueGrabbing;
1219         break;
1220     case CursorEResize:
1221         m_value.valueID = CSSValueEResize;
1222         break;
1223     case CursorNResize:
1224         m_value.valueID = CSSValueNResize;
1225         break;
1226     case CursorNeResize:
1227         m_value.valueID = CSSValueNeResize;
1228         break;
1229     case CursorNwResize:
1230         m_value.valueID = CSSValueNwResize;
1231         break;
1232     case CursorSResize:
1233         m_value.valueID = CSSValueSResize;
1234         break;
1235     case CursorSeResize:
1236         m_value.valueID = CSSValueSeResize;
1237         break;
1238     case CursorSwResize:
1239         m_value.valueID = CSSValueSwResize;
1240         break;
1241     case CursorWResize:
1242         m_value.valueID = CSSValueWResize;
1243         break;
1244     case CursorEwResize:
1245         m_value.valueID = CSSValueEwResize;
1246         break;
1247     case CursorNsResize:
1248         m_value.valueID = CSSValueNsResize;
1249         break;
1250     case CursorNeswResize:
1251         m_value.valueID = CSSValueNeswResize;
1252         break;
1253     case CursorNwseResize:
1254         m_value.valueID = CSSValueNwseResize;
1255         break;
1256     case CursorColResize:
1257         m_value.valueID = CSSValueColResize;
1258         break;
1259     case CursorRowResize:
1260         m_value.valueID = CSSValueRowResize;
1261         break;
1262     case CursorAllScroll:
1263         m_value.valueID = CSSValueAllScroll;
1264         break;
1265     case CursorZoomIn:
1266         m_value.valueID = CSSValueZoomIn;
1267         break;
1268     case CursorZoomOut:
1269         m_value.valueID = CSSValueZoomOut;
1270         break;
1271     }
1272 }
1273
1274 template<> inline CSSPrimitiveValue::operator ECursor() const
1275 {
1276     ASSERT(isValueID());
1277     switch (m_value.valueID) {
1278     case CSSValueCopy:
1279         return CursorCopy;
1280     case CSSValueWebkitGrab:
1281         return CursorGrab;
1282     case CSSValueWebkitGrabbing:
1283         return CursorGrabbing;
1284     case CSSValueWebkitZoomIn:
1285         return CursorZoomIn;
1286     case CSSValueWebkitZoomOut:
1287         return CursorZoomOut;
1288     case CSSValueNone:
1289         return CursorNone;
1290     default:
1291         return static_cast<ECursor>(m_value.valueID - CSSValueAuto);
1292     }
1293 }
1294
1295 #if ENABLE(CURSOR_VISIBILITY)
1296 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(CursorVisibility e)
1297     : CSSValue(PrimitiveClass)
1298 {
1299     m_primitiveUnitType = CSS_VALUE_ID;
1300     switch (e) {
1301     case CursorVisibilityAuto:
1302         m_value.valueID = CSSValueAuto;
1303         break;
1304     case CursorVisibilityAutoHide:
1305         m_value.valueID = CSSValueAutoHide;
1306         break;
1307     }
1308 }
1309
1310 template<> inline CSSPrimitiveValue::operator CursorVisibility() const
1311 {
1312     ASSERT(isValueID());
1313
1314     if (m_value.valueID == CSSValueAuto)
1315         return CursorVisibilityAuto;
1316     if (m_value.valueID == CSSValueAutoHide)
1317         return CursorVisibilityAutoHide;
1318
1319     ASSERT_NOT_REACHED();
1320     return CursorVisibilityAuto;
1321 }
1322 #endif
1323
1324 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EDisplay e)
1325     : CSSValue(PrimitiveClass)
1326 {
1327     m_primitiveUnitType = CSS_VALUE_ID;
1328     switch (e) {
1329     case INLINE:
1330         m_value.valueID = CSSValueInline;
1331         break;
1332     case BLOCK:
1333         m_value.valueID = CSSValueBlock;
1334         break;
1335     case LIST_ITEM:
1336         m_value.valueID = CSSValueListItem;
1337         break;
1338     case COMPACT:
1339         m_value.valueID = CSSValueCompact;
1340         break;
1341     case INLINE_BLOCK:
1342         m_value.valueID = CSSValueInlineBlock;
1343         break;
1344     case TABLE:
1345         m_value.valueID = CSSValueTable;
1346         break;
1347     case INLINE_TABLE:
1348         m_value.valueID = CSSValueInlineTable;
1349         break;
1350     case TABLE_ROW_GROUP:
1351         m_value.valueID = CSSValueTableRowGroup;
1352         break;
1353     case TABLE_HEADER_GROUP:
1354         m_value.valueID = CSSValueTableHeaderGroup;
1355         break;
1356     case TABLE_FOOTER_GROUP:
1357         m_value.valueID = CSSValueTableFooterGroup;
1358         break;
1359     case TABLE_ROW:
1360         m_value.valueID = CSSValueTableRow;
1361         break;
1362     case TABLE_COLUMN_GROUP:
1363         m_value.valueID = CSSValueTableColumnGroup;
1364         break;
1365     case TABLE_COLUMN:
1366         m_value.valueID = CSSValueTableColumn;
1367         break;
1368     case TABLE_CELL:
1369         m_value.valueID = CSSValueTableCell;
1370         break;
1371     case TABLE_CAPTION:
1372         m_value.valueID = CSSValueTableCaption;
1373         break;
1374     case BOX:
1375         m_value.valueID = CSSValueWebkitBox;
1376         break;
1377     case INLINE_BOX:
1378         m_value.valueID = CSSValueWebkitInlineBox;
1379         break;
1380     case FLEX:
1381     case WEBKIT_FLEX:
1382         m_value.valueID = CSSValueFlex;
1383         break;
1384     case INLINE_FLEX:
1385     case WEBKIT_INLINE_FLEX:
1386         m_value.valueID = CSSValueInlineFlex;
1387         break;
1388     case GRID:
1389         m_value.valueID = CSSValueGrid;
1390         break;
1391     case INLINE_GRID:
1392         m_value.valueID = CSSValueInlineGrid;
1393         break;
1394     case NONE:
1395         m_value.valueID = CSSValueNone;
1396         break;
1397     case CONTENTS:
1398         m_value.valueID = CSSValueContents;
1399         break;
1400     }
1401 }
1402
1403 template<> inline CSSPrimitiveValue::operator EDisplay() const
1404 {
1405     ASSERT(isValueID());
1406
1407     if (m_value.valueID == CSSValueNone)
1408         return NONE;
1409
1410     EDisplay display = static_cast<EDisplay>(m_value.valueID - CSSValueInline);
1411     ASSERT(display >= INLINE && display <= NONE);
1412     if (display == WEBKIT_FLEX)
1413         return FLEX;
1414     if (display == WEBKIT_INLINE_FLEX)
1415         return INLINE_FLEX;
1416     return display;
1417 }
1418
1419 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EEmptyCell e)
1420     : CSSValue(PrimitiveClass)
1421 {
1422     m_primitiveUnitType = CSS_VALUE_ID;
1423     switch (e) {
1424     case SHOW:
1425         m_value.valueID = CSSValueShow;
1426         break;
1427     case HIDE:
1428         m_value.valueID = CSSValueHide;
1429         break;
1430     }
1431 }
1432
1433 template<> inline CSSPrimitiveValue::operator EEmptyCell() const
1434 {
1435     ASSERT(isValueID());
1436
1437     switch (m_value.valueID) {
1438     case CSSValueShow:
1439         return SHOW;
1440     case CSSValueHide:
1441         return HIDE;
1442     default:
1443         break;
1444     }
1445
1446     ASSERT_NOT_REACHED();
1447     return SHOW;
1448 }
1449
1450 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFlexDirection e)
1451     : CSSValue(PrimitiveClass)
1452 {
1453     m_primitiveUnitType = CSS_VALUE_ID;
1454     switch (e) {
1455     case FlowRow:
1456         m_value.valueID = CSSValueRow;
1457         break;
1458     case FlowRowReverse:
1459         m_value.valueID = CSSValueRowReverse;
1460         break;
1461     case FlowColumn:
1462         m_value.valueID = CSSValueColumn;
1463         break;
1464     case FlowColumnReverse:
1465         m_value.valueID = CSSValueColumnReverse;
1466         break;
1467     }
1468 }
1469
1470 template<> inline CSSPrimitiveValue::operator EFlexDirection() const
1471 {
1472     ASSERT(isValueID());
1473
1474     switch (m_value.valueID) {
1475     case CSSValueRow:
1476         return FlowRow;
1477     case CSSValueRowReverse:
1478         return FlowRowReverse;
1479     case CSSValueColumn:
1480         return FlowColumn;
1481     case CSSValueColumnReverse:
1482         return FlowColumnReverse;
1483     default:
1484         break;
1485     }
1486
1487     ASSERT_NOT_REACHED();
1488     return FlowRow;
1489 }
1490
1491 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EAlignContent e)
1492     : CSSValue(PrimitiveClass)
1493 {
1494     m_primitiveUnitType = CSS_VALUE_ID;
1495     switch (e) {
1496     case AlignContentFlexStart:
1497         m_value.valueID = CSSValueFlexStart;
1498         break;
1499     case AlignContentFlexEnd:
1500         m_value.valueID = CSSValueFlexEnd;
1501         break;
1502     case AlignContentCenter:
1503         m_value.valueID = CSSValueCenter;
1504         break;
1505     case AlignContentSpaceBetween:
1506         m_value.valueID = CSSValueSpaceBetween;
1507         break;
1508     case AlignContentSpaceAround:
1509         m_value.valueID = CSSValueSpaceAround;
1510         break;
1511     case AlignContentStretch:
1512         m_value.valueID = CSSValueStretch;
1513         break;
1514     }
1515 }
1516
1517 template<> inline CSSPrimitiveValue::operator EAlignContent() const
1518 {
1519     ASSERT(isValueID());
1520
1521     switch (m_value.valueID) {
1522     case CSSValueFlexStart:
1523         return AlignContentFlexStart;
1524     case CSSValueFlexEnd:
1525         return AlignContentFlexEnd;
1526     case CSSValueCenter:
1527         return AlignContentCenter;
1528     case CSSValueSpaceBetween:
1529         return AlignContentSpaceBetween;
1530     case CSSValueSpaceAround:
1531         return AlignContentSpaceAround;
1532     case CSSValueStretch:
1533         return AlignContentStretch;
1534     default:
1535         break;
1536     }
1537
1538     ASSERT_NOT_REACHED();
1539     return AlignContentStretch;
1540 }
1541
1542 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFlexWrap e)
1543     : CSSValue(PrimitiveClass)
1544 {
1545     m_primitiveUnitType = CSS_VALUE_ID;
1546     switch (e) {
1547     case FlexNoWrap:
1548         m_value.valueID = CSSValueNowrap;
1549         break;
1550     case FlexWrap:
1551         m_value.valueID = CSSValueWrap;
1552         break;
1553     case FlexWrapReverse:
1554         m_value.valueID = CSSValueWrapReverse;
1555         break;
1556     }
1557 }
1558
1559 template<> inline CSSPrimitiveValue::operator EFlexWrap() const
1560 {
1561     ASSERT(isValueID());
1562
1563     switch (m_value.valueID) {
1564     case CSSValueNowrap:
1565         return FlexNoWrap;
1566     case CSSValueWrap:
1567         return FlexWrap;
1568     case CSSValueWrapReverse:
1569         return FlexWrapReverse;
1570     default:
1571         break;
1572     }
1573
1574     ASSERT_NOT_REACHED();
1575     return FlexNoWrap;
1576 }
1577
1578 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFloat e)
1579     : CSSValue(PrimitiveClass)
1580 {
1581     m_primitiveUnitType = CSS_VALUE_ID;
1582     switch (e) {
1583     case NoFloat:
1584         m_value.valueID = CSSValueNone;
1585         break;
1586     case LeftFloat:
1587         m_value.valueID = CSSValueLeft;
1588         break;
1589     case RightFloat:
1590         m_value.valueID = CSSValueRight;
1591         break;
1592     }
1593 }
1594
1595 template<> inline CSSPrimitiveValue::operator EFloat() const
1596 {
1597     ASSERT(isValueID());
1598
1599     switch (m_value.valueID) {
1600     case CSSValueLeft:
1601         return LeftFloat;
1602     case CSSValueRight:
1603         return RightFloat;
1604     case CSSValueNone:
1605     case CSSValueCenter: // Non-standard CSS value.
1606         return NoFloat;
1607     default:
1608         break;
1609     }
1610
1611     ASSERT_NOT_REACHED();
1612     return NoFloat;
1613 }
1614
1615 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineBreak e)
1616     : CSSValue(PrimitiveClass)
1617 {
1618     m_primitiveUnitType = CSS_VALUE_ID;
1619     switch (e) {
1620     case LineBreakAuto:
1621         m_value.valueID = CSSValueAuto;
1622         break;
1623     case LineBreakLoose:
1624         m_value.valueID = CSSValueLoose;
1625         break;
1626     case LineBreakNormal:
1627         m_value.valueID = CSSValueNormal;
1628         break;
1629     case LineBreakStrict:
1630         m_value.valueID = CSSValueStrict;
1631         break;
1632     case LineBreakAfterWhiteSpace:
1633         m_value.valueID = CSSValueAfterWhiteSpace;
1634         break;
1635     }
1636 }
1637
1638 template<> inline CSSPrimitiveValue::operator HangingPunctuation() const
1639 {
1640     ASSERT(isValueID());
1641
1642     switch (m_value.valueID) {
1643     case CSSValueNone:
1644         return NoHangingPunctuation;
1645     case CSSValueFirst:
1646         return FirstHangingPunctuation;
1647     case CSSValueLast:
1648         return LastHangingPunctuation;
1649     case CSSValueAllowEnd:
1650         return AllowEndHangingPunctuation;
1651     case CSSValueForceEnd:
1652         return ForceEndHangingPunctuation;
1653     default:
1654         break;
1655     }
1656
1657     ASSERT_NOT_REACHED();
1658     return NoHangingPunctuation;
1659 }
1660
1661 template<> inline CSSPrimitiveValue::operator LineBreak() const
1662 {
1663     ASSERT(isValueID());
1664
1665     switch (m_value.valueID) {
1666     case CSSValueAuto:
1667         return LineBreakAuto;
1668     case CSSValueLoose:
1669         return LineBreakLoose;
1670     case CSSValueNormal:
1671         return LineBreakNormal;
1672     case CSSValueStrict:
1673         return LineBreakStrict;
1674     case CSSValueAfterWhiteSpace:
1675         return LineBreakAfterWhiteSpace;
1676     default:
1677         break;
1678     }
1679
1680     ASSERT_NOT_REACHED();
1681     return LineBreakAuto;
1682 }
1683
1684 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EListStylePosition e)
1685     : CSSValue(PrimitiveClass)
1686 {
1687     m_primitiveUnitType = CSS_VALUE_ID;
1688     switch (e) {
1689     case OUTSIDE:
1690         m_value.valueID = CSSValueOutside;
1691         break;
1692     case INSIDE:
1693         m_value.valueID = CSSValueInside;
1694         break;
1695     }
1696 }
1697
1698 template<> inline CSSPrimitiveValue::operator EListStylePosition() const
1699 {
1700     ASSERT(isValueID());
1701
1702     switch (m_value.valueID) {
1703     case CSSValueOutside:
1704         return OUTSIDE;
1705     case CSSValueInside:
1706         return INSIDE;
1707     default:
1708         break;
1709     }
1710
1711     ASSERT_NOT_REACHED();
1712     return OUTSIDE;
1713 }
1714
1715 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EListStyleType e)
1716     : CSSValue(PrimitiveClass)
1717 {
1718     m_primitiveUnitType = CSS_VALUE_ID;
1719     switch (e) {
1720     case Afar:
1721         m_value.valueID = CSSValueAfar;
1722         break;
1723     case Amharic:
1724         m_value.valueID = CSSValueAmharic;
1725         break;
1726     case AmharicAbegede:
1727         m_value.valueID = CSSValueAmharicAbegede;
1728         break;
1729     case ArabicIndic:
1730         m_value.valueID = CSSValueArabicIndic;
1731         break;
1732     case Armenian:
1733         m_value.valueID = CSSValueArmenian;
1734         break;
1735     case Asterisks:
1736         m_value.valueID = CSSValueAsterisks;
1737         break;
1738     case BinaryListStyle:
1739         m_value.valueID = CSSValueBinary;
1740         break;
1741     case Bengali:
1742         m_value.valueID = CSSValueBengali;
1743         break;
1744     case Cambodian:
1745         m_value.valueID = CSSValueCambodian;
1746         break;
1747     case Circle:
1748         m_value.valueID = CSSValueCircle;
1749         break;
1750     case CjkEarthlyBranch:
1751         m_value.valueID = CSSValueCjkEarthlyBranch;
1752         break;
1753     case CjkHeavenlyStem:
1754         m_value.valueID = CSSValueCjkHeavenlyStem;
1755         break;
1756     case CJKIdeographic:
1757         m_value.valueID = CSSValueCjkIdeographic;
1758         break;
1759     case DecimalLeadingZero:
1760         m_value.valueID = CSSValueDecimalLeadingZero;
1761         break;
1762     case DecimalListStyle:
1763         m_value.valueID = CSSValueDecimal;
1764         break;
1765     case Devanagari:
1766         m_value.valueID = CSSValueDevanagari;
1767         break;
1768     case Disc:
1769         m_value.valueID = CSSValueDisc;
1770         break;
1771     case Ethiopic:
1772         m_value.valueID = CSSValueEthiopic;
1773         break;
1774     case EthiopicAbegede:
1775         m_value.valueID = CSSValueEthiopicAbegede;
1776         break;
1777     case EthiopicAbegedeAmEt:
1778         m_value.valueID = CSSValueEthiopicAbegedeAmEt;
1779         break;
1780     case EthiopicAbegedeGez:
1781         m_value.valueID = CSSValueEthiopicAbegedeGez;
1782         break;
1783     case EthiopicAbegedeTiEr:
1784         m_value.valueID = CSSValueEthiopicAbegedeTiEr;
1785         break;
1786     case EthiopicAbegedeTiEt:
1787         m_value.valueID = CSSValueEthiopicAbegedeTiEt;
1788         break;
1789     case EthiopicHalehameAaEr:
1790         m_value.valueID = CSSValueEthiopicHalehameAaEr;
1791         break;
1792     case EthiopicHalehameAaEt:
1793         m_value.valueID = CSSValueEthiopicHalehameAaEt;
1794         break;
1795     case EthiopicHalehameAmEt:
1796         m_value.valueID = CSSValueEthiopicHalehameAmEt;
1797         break;
1798     case EthiopicHalehameGez:
1799         m_value.valueID = CSSValueEthiopicHalehameGez;
1800         break;
1801     case EthiopicHalehameOmEt:
1802         m_value.valueID = CSSValueEthiopicHalehameOmEt;
1803         break;
1804     case EthiopicHalehameSidEt:
1805         m_value.valueID = CSSValueEthiopicHalehameSidEt;
1806         break;
1807     case EthiopicHalehameSoEt:
1808         m_value.valueID = CSSValueEthiopicHalehameSoEt;
1809         break;
1810     case EthiopicHalehameTiEr:
1811         m_value.valueID = CSSValueEthiopicHalehameTiEr;
1812         break;
1813     case EthiopicHalehameTiEt:
1814         m_value.valueID = CSSValueEthiopicHalehameTiEt;
1815         break;
1816     case EthiopicHalehameTig:
1817         m_value.valueID = CSSValueEthiopicHalehameTig;
1818         break;
1819     case Footnotes:
1820         m_value.valueID = CSSValueFootnotes;
1821         break;
1822     case Georgian:
1823         m_value.valueID = CSSValueGeorgian;
1824         break;
1825     case Gujarati:
1826         m_value.valueID = CSSValueGujarati;
1827         break;
1828     case Gurmukhi:
1829         m_value.valueID = CSSValueGurmukhi;
1830         break;
1831     case Hangul:
1832         m_value.valueID = CSSValueHangul;
1833         break;
1834     case HangulConsonant:
1835         m_value.valueID = CSSValueHangulConsonant;
1836         break;
1837     case Hebrew:
1838         m_value.valueID = CSSValueHebrew;
1839         break;
1840     case Hiragana:
1841         m_value.valueID = CSSValueHiragana;
1842         break;
1843     case HiraganaIroha:
1844         m_value.valueID = CSSValueHiraganaIroha;
1845         break;
1846     case Kannada:
1847         m_value.valueID = CSSValueKannada;
1848         break;
1849     case Katakana:
1850         m_value.valueID = CSSValueKatakana;
1851         break;
1852     case KatakanaIroha:
1853         m_value.valueID = CSSValueKatakanaIroha;
1854         break;
1855     case Khmer:
1856         m_value.valueID = CSSValueKhmer;
1857         break;
1858     case Lao:
1859         m_value.valueID = CSSValueLao;
1860         break;
1861     case LowerAlpha:
1862         m_value.valueID = CSSValueLowerAlpha;
1863         break;
1864     case LowerArmenian:
1865         m_value.valueID = CSSValueLowerArmenian;
1866         break;
1867     case LowerGreek:
1868         m_value.valueID = CSSValueLowerGreek;
1869         break;
1870     case LowerHexadecimal:
1871         m_value.valueID = CSSValueLowerHexadecimal;
1872         break;
1873     case LowerLatin:
1874         m_value.valueID = CSSValueLowerLatin;
1875         break;
1876     case LowerNorwegian:
1877         m_value.valueID = CSSValueLowerNorwegian;
1878         break;
1879     case LowerRoman:
1880         m_value.valueID = CSSValueLowerRoman;
1881         break;
1882     case Malayalam:
1883         m_value.valueID = CSSValueMalayalam;
1884         break;
1885     case Mongolian:
1886         m_value.valueID = CSSValueMongolian;
1887         break;
1888     case Myanmar:
1889         m_value.valueID = CSSValueMyanmar;
1890         break;
1891     case NoneListStyle:
1892         m_value.valueID = CSSValueNone;
1893         break;
1894     case Octal:
1895         m_value.valueID = CSSValueOctal;
1896         break;
1897     case Oriya:
1898         m_value.valueID = CSSValueOriya;
1899         break;
1900     case Oromo:
1901         m_value.valueID = CSSValueOromo;
1902         break;
1903     case Persian:
1904         m_value.valueID = CSSValuePersian;
1905         break;
1906     case Sidama:
1907         m_value.valueID = CSSValueSidama;
1908         break;
1909     case Somali:
1910         m_value.valueID = CSSValueSomali;
1911         break;
1912     case Square:
1913         m_value.valueID = CSSValueSquare;
1914         break;
1915     case Telugu:
1916         m_value.valueID = CSSValueTelugu;
1917         break;
1918     case Thai:
1919         m_value.valueID = CSSValueThai;
1920         break;
1921     case Tibetan:
1922         m_value.valueID = CSSValueTibetan;
1923         break;
1924     case Tigre:
1925         m_value.valueID = CSSValueTigre;
1926         break;
1927     case TigrinyaEr:
1928         m_value.valueID = CSSValueTigrinyaEr;
1929         break;
1930     case TigrinyaErAbegede:
1931         m_value.valueID = CSSValueTigrinyaErAbegede;
1932         break;
1933     case TigrinyaEt:
1934         m_value.valueID = CSSValueTigrinyaEt;
1935         break;
1936     case TigrinyaEtAbegede:
1937         m_value.valueID = CSSValueTigrinyaEtAbegede;
1938         break;
1939     case UpperAlpha:
1940         m_value.valueID = CSSValueUpperAlpha;
1941         break;
1942     case UpperArmenian:
1943         m_value.valueID = CSSValueUpperArmenian;
1944         break;
1945     case UpperGreek:
1946         m_value.valueID = CSSValueUpperGreek;
1947         break;
1948     case UpperHexadecimal:
1949         m_value.valueID = CSSValueUpperHexadecimal;
1950         break;
1951     case UpperLatin:
1952         m_value.valueID = CSSValueUpperLatin;
1953         break;
1954     case UpperNorwegian:
1955         m_value.valueID = CSSValueUpperNorwegian;
1956         break;
1957     case UpperRoman:
1958         m_value.valueID = CSSValueUpperRoman;
1959         break;
1960     case Urdu:
1961         m_value.valueID = CSSValueUrdu;
1962         break;
1963     }
1964 }
1965
1966 template<> inline CSSPrimitiveValue::operator EListStyleType() const
1967 {
1968     ASSERT(isValueID());
1969
1970     switch (m_value.valueID) {
1971     case CSSValueNone:
1972         return NoneListStyle;
1973     default:
1974         return static_cast<EListStyleType>(m_value.valueID - CSSValueDisc);
1975     }
1976 }
1977
1978 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EMarginCollapse e)
1979     : CSSValue(PrimitiveClass)
1980 {
1981     m_primitiveUnitType = CSS_VALUE_ID;
1982     switch (e) {
1983     case MCOLLAPSE:
1984         m_value.valueID = CSSValueCollapse;
1985         break;
1986     case MSEPARATE:
1987         m_value.valueID = CSSValueSeparate;
1988         break;
1989     case MDISCARD:
1990         m_value.valueID = CSSValueDiscard;
1991         break;
1992     }
1993 }
1994
1995 template<> inline CSSPrimitiveValue::operator EMarginCollapse() const
1996 {
1997     ASSERT(isValueID());
1998
1999     switch (m_value.valueID) {
2000     case CSSValueCollapse:
2001         return MCOLLAPSE;
2002     case CSSValueSeparate:
2003         return MSEPARATE;
2004     case CSSValueDiscard:
2005         return MDISCARD;
2006     default:
2007         break;
2008     }
2009
2010     ASSERT_NOT_REACHED();
2011     return MCOLLAPSE;
2012 }
2013
2014 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EMarqueeBehavior e)
2015     : CSSValue(PrimitiveClass)
2016 {
2017     m_primitiveUnitType = CSS_VALUE_ID;
2018     switch (e) {
2019     case MNONE:
2020         m_value.valueID = CSSValueNone;
2021         break;
2022     case MSCROLL:
2023         m_value.valueID = CSSValueScroll;
2024         break;
2025     case MSLIDE:
2026         m_value.valueID = CSSValueSlide;
2027         break;
2028     case MALTERNATE:
2029         m_value.valueID = CSSValueAlternate;
2030         break;
2031     }
2032 }
2033
2034 template<> inline CSSPrimitiveValue::operator EMarqueeBehavior() const
2035 {
2036     ASSERT(isValueID());
2037
2038     switch (m_value.valueID) {
2039     case CSSValueNone:
2040         return MNONE;
2041     case CSSValueScroll:
2042         return MSCROLL;
2043     case CSSValueSlide:
2044         return MSLIDE;
2045     case CSSValueAlternate:
2046         return MALTERNATE;
2047     default:
2048         break;
2049     }
2050
2051     ASSERT_NOT_REACHED();
2052     return MNONE;
2053 }
2054
2055 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(RegionFragment e)
2056     : CSSValue(PrimitiveClass)
2057 {
2058     m_primitiveUnitType = CSS_VALUE_ID;
2059     switch (e) {
2060     case AutoRegionFragment:
2061         m_value.valueID = CSSValueAuto;
2062         break;
2063     case BreakRegionFragment:
2064         m_value.valueID = CSSValueBreak;
2065         break;
2066     }
2067 }
2068
2069 template<> inline CSSPrimitiveValue::operator RegionFragment() const
2070 {
2071     ASSERT(isValueID());
2072
2073     switch (m_value.valueID) {
2074     case CSSValueAuto:
2075         return AutoRegionFragment;
2076     case CSSValueBreak:
2077         return BreakRegionFragment;
2078     default:
2079         break;
2080     }
2081
2082     ASSERT_NOT_REACHED();
2083     return AutoRegionFragment;
2084 }
2085
2086 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EMarqueeDirection e)
2087     : CSSValue(PrimitiveClass)
2088 {
2089     m_primitiveUnitType = CSS_VALUE_ID;
2090     switch (e) {
2091     case MFORWARD:
2092         m_value.valueID = CSSValueForwards;
2093         break;
2094     case MBACKWARD:
2095         m_value.valueID = CSSValueBackwards;
2096         break;
2097     case MAUTO:
2098         m_value.valueID = CSSValueAuto;
2099         break;
2100     case MUP:
2101         m_value.valueID = CSSValueUp;
2102         break;
2103     case MDOWN:
2104         m_value.valueID = CSSValueDown;
2105         break;
2106     case MLEFT:
2107         m_value.valueID = CSSValueLeft;
2108         break;
2109     case MRIGHT:
2110         m_value.valueID = CSSValueRight;
2111         break;
2112     }
2113 }
2114
2115 template<> inline CSSPrimitiveValue::operator EMarqueeDirection() const
2116 {
2117     ASSERT(isValueID());
2118
2119     switch (m_value.valueID) {
2120     case CSSValueForwards:
2121         return MFORWARD;
2122     case CSSValueBackwards:
2123         return MBACKWARD;
2124     case CSSValueAuto:
2125         return MAUTO;
2126     case CSSValueAhead:
2127     case CSSValueUp: // We don't support vertical languages, so AHEAD just maps to UP.
2128         return MUP;
2129     case CSSValueReverse:
2130     case CSSValueDown: // REVERSE just maps to DOWN, since we don't do vertical text.
2131         return MDOWN;
2132     case CSSValueLeft:
2133         return MLEFT;
2134     case CSSValueRight:
2135         return MRIGHT;
2136     default:
2137         break;
2138     }
2139
2140     ASSERT_NOT_REACHED();
2141     return MAUTO;
2142 }
2143
2144 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ENBSPMode e)
2145     : CSSValue(PrimitiveClass)
2146 {
2147     m_primitiveUnitType = CSS_VALUE_ID;
2148     switch (e) {
2149     case NBNORMAL:
2150         m_value.valueID = CSSValueNormal;
2151         break;
2152     case SPACE:
2153         m_value.valueID = CSSValueSpace;
2154         break;
2155     }
2156 }
2157
2158 template<> inline CSSPrimitiveValue::operator ENBSPMode() const
2159 {
2160     ASSERT(isValueID());
2161
2162     switch (m_value.valueID) {
2163     case CSSValueSpace:
2164         return SPACE;
2165     case CSSValueNormal:
2166         return NBNORMAL;
2167     default:
2168         break;
2169     }
2170
2171     ASSERT_NOT_REACHED();
2172     return NBNORMAL;
2173 }
2174
2175 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EOverflow e)
2176     : CSSValue(PrimitiveClass)
2177 {
2178     m_primitiveUnitType = CSS_VALUE_ID;
2179     switch (e) {
2180     case OVISIBLE:
2181         m_value.valueID = CSSValueVisible;
2182         break;
2183     case OHIDDEN:
2184         m_value.valueID = CSSValueHidden;
2185         break;
2186     case OSCROLL:
2187         m_value.valueID = CSSValueScroll;
2188         break;
2189     case OAUTO:
2190         m_value.valueID = CSSValueAuto;
2191         break;
2192     case OOVERLAY:
2193         m_value.valueID = CSSValueOverlay;
2194         break;
2195     case OPAGEDX:
2196         m_value.valueID = CSSValueWebkitPagedX;
2197         break;
2198     case OPAGEDY:
2199         m_value.valueID = CSSValueWebkitPagedY;
2200         break;
2201     }
2202 }
2203
2204 template<> inline CSSPrimitiveValue::operator EOverflow() const
2205 {
2206     ASSERT(isValueID());
2207
2208     switch (m_value.valueID) {
2209     case CSSValueVisible:
2210         return OVISIBLE;
2211     case CSSValueHidden:
2212         return OHIDDEN;
2213     case CSSValueScroll:
2214         return OSCROLL;
2215     case CSSValueAuto:
2216         return OAUTO;
2217     case CSSValueOverlay:
2218         return OOVERLAY;
2219     case CSSValueWebkitPagedX:
2220         return OPAGEDX;
2221     case CSSValueWebkitPagedY:
2222         return OPAGEDY;
2223     default:
2224         break;
2225     }
2226
2227     ASSERT_NOT_REACHED();
2228     return OVISIBLE;
2229 }
2230
2231 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(BreakBetween e)
2232     : CSSValue(PrimitiveClass)
2233 {
2234     m_primitiveUnitType = CSS_VALUE_ID;
2235     switch (e) {
2236     case AutoBreakBetween:
2237         m_value.valueID = CSSValueAuto;
2238         break;
2239     case AvoidBreakBetween:
2240         m_value.valueID = CSSValueAvoid;
2241         break;
2242     case AvoidColumnBreakBetween:
2243         m_value.valueID = CSSValueAvoidColumn;
2244         break;
2245     case AvoidPageBreakBetween:
2246         m_value.valueID = CSSValueAvoidPage;
2247         break;
2248     case AvoidRegionBreakBetween:
2249         m_value.valueID = CSSValueAvoidRegion;
2250         break;
2251     case ColumnBreakBetween:
2252         m_value.valueID = CSSValueColumn;
2253         break;
2254     case PageBreakBetween:
2255         m_value.valueID = CSSValuePage;
2256         break;
2257     case RegionBreakBetween:
2258         m_value.valueID = CSSValueRegion;
2259         break;
2260     case LeftPageBreakBetween:
2261         m_value.valueID = CSSValueLeft;
2262         break;
2263     case RightPageBreakBetween:
2264         m_value.valueID = CSSValueRight;
2265         break;
2266     case RectoPageBreakBetween:
2267         m_value.valueID = CSSValueRecto;
2268         break;
2269     case VersoPageBreakBetween:
2270         m_value.valueID = CSSValueVerso;
2271         break;
2272     }
2273 }
2274
2275 template<> inline CSSPrimitiveValue::operator BreakBetween() const
2276 {
2277     ASSERT(isValueID());
2278
2279     switch (m_value.valueID) {
2280     case CSSValueAuto:
2281         return AutoBreakBetween;
2282     case CSSValueAvoid:
2283         return AvoidBreakBetween;
2284     case CSSValueAvoidColumn:
2285         return AvoidColumnBreakBetween;
2286     case CSSValueAvoidPage:
2287         return AvoidPageBreakBetween;
2288     case CSSValueAvoidRegion:
2289         return AvoidRegionBreakBetween;
2290     case CSSValueColumn:
2291         return ColumnBreakBetween;
2292     case CSSValuePage:
2293         return PageBreakBetween;
2294     case CSSValueRegion:
2295         return RegionBreakBetween;
2296     case CSSValueLeft:
2297         return LeftPageBreakBetween;
2298     case CSSValueRight:
2299         return RightPageBreakBetween;
2300     case CSSValueRecto:
2301         return RectoPageBreakBetween;
2302     case CSSValueVerso:
2303         return VersoPageBreakBetween;
2304     default:
2305         break;
2306     }
2307
2308     ASSERT_NOT_REACHED();
2309     return AutoBreakBetween;
2310 }
2311
2312 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(BreakInside e)
2313     : CSSValue(PrimitiveClass)
2314 {
2315     m_primitiveUnitType = CSS_VALUE_ID;
2316     switch (e) {
2317     case AutoBreakInside:
2318         m_value.valueID = CSSValueAuto;
2319         break;
2320     case AvoidBreakInside:
2321         m_value.valueID = CSSValueAvoid;
2322         break;
2323     case AvoidColumnBreakInside:
2324         m_value.valueID = CSSValueAvoidColumn;
2325         break;
2326     case AvoidPageBreakInside:
2327         m_value.valueID = CSSValueAvoidPage;
2328         break;
2329     case AvoidRegionBreakInside:
2330         m_value.valueID = CSSValueAvoidRegion;
2331         break;
2332     }
2333 }
2334
2335 template<> inline CSSPrimitiveValue::operator BreakInside() const
2336 {
2337     ASSERT(isValueID());
2338
2339     switch (m_value.valueID) {
2340     case CSSValueAuto:
2341         return AutoBreakInside;
2342     case CSSValueAvoid:
2343         return AvoidBreakInside;
2344     case CSSValueAvoidColumn:
2345         return AvoidColumnBreakInside;
2346     case CSSValueAvoidPage:
2347         return AvoidPageBreakInside;
2348     case CSSValueAvoidRegion:
2349         return AvoidRegionBreakInside;
2350     default:
2351         break;
2352     }
2353
2354     ASSERT_NOT_REACHED();
2355     return AutoBreakInside;
2356 }
2357
2358 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EPosition e)
2359     : CSSValue(PrimitiveClass)
2360 {
2361     m_primitiveUnitType = CSS_VALUE_ID;
2362     switch (e) {
2363     case StaticPosition:
2364         m_value.valueID = CSSValueStatic;
2365         break;
2366     case RelativePosition:
2367         m_value.valueID = CSSValueRelative;
2368         break;
2369     case AbsolutePosition:
2370         m_value.valueID = CSSValueAbsolute;
2371         break;
2372     case FixedPosition:
2373         m_value.valueID = CSSValueFixed;
2374         break;
2375     case StickyPosition:
2376         m_value.valueID = CSSValueWebkitSticky;
2377         break;
2378     }
2379 }
2380
2381 template<> inline CSSPrimitiveValue::operator EPosition() const
2382 {
2383     ASSERT(isValueID());
2384
2385     switch (m_value.valueID) {
2386     case CSSValueStatic:
2387         return StaticPosition;
2388     case CSSValueRelative:
2389         return RelativePosition;
2390     case CSSValueAbsolute:
2391         return AbsolutePosition;
2392     case CSSValueFixed:
2393         return FixedPosition;
2394     case CSSValueWebkitSticky:
2395         return StickyPosition;
2396     default:
2397         break;
2398     }
2399
2400     ASSERT_NOT_REACHED();
2401     return StaticPosition;
2402 }
2403
2404 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EResize e)
2405     : CSSValue(PrimitiveClass)
2406 {
2407     m_primitiveUnitType = CSS_VALUE_ID;
2408     switch (e) {
2409     case RESIZE_BOTH:
2410         m_value.valueID = CSSValueBoth;
2411         break;
2412     case RESIZE_HORIZONTAL:
2413         m_value.valueID = CSSValueHorizontal;
2414         break;
2415     case RESIZE_VERTICAL:
2416         m_value.valueID = CSSValueVertical;
2417         break;
2418     case RESIZE_NONE:
2419         m_value.valueID = CSSValueNone;
2420         break;
2421     }
2422 }
2423
2424 template<> inline CSSPrimitiveValue::operator EResize() const
2425 {
2426     ASSERT(isValueID());
2427
2428     switch (m_value.valueID) {
2429     case CSSValueBoth:
2430         return RESIZE_BOTH;
2431     case CSSValueHorizontal:
2432         return RESIZE_HORIZONTAL;
2433     case CSSValueVertical:
2434         return RESIZE_VERTICAL;
2435     case CSSValueAuto:
2436         ASSERT_NOT_REACHED(); // Depends on settings, thus should be handled by the caller.
2437         return RESIZE_NONE;
2438     case CSSValueNone:
2439         return RESIZE_NONE;
2440     default:
2441         break;
2442     }
2443
2444     ASSERT_NOT_REACHED();
2445     return RESIZE_NONE;
2446 }
2447
2448 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETableLayout e)
2449     : CSSValue(PrimitiveClass)
2450 {
2451     m_primitiveUnitType = CSS_VALUE_ID;
2452     switch (e) {
2453     case TAUTO:
2454         m_value.valueID = CSSValueAuto;
2455         break;
2456     case TFIXED:
2457         m_value.valueID = CSSValueFixed;
2458         break;
2459     }
2460 }
2461
2462 template<> inline CSSPrimitiveValue::operator ETableLayout() const
2463 {
2464     ASSERT(isValueID());
2465
2466     switch (m_value.valueID) {
2467     case CSSValueFixed:
2468         return TFIXED;
2469     case CSSValueAuto:
2470         return TAUTO;
2471     default:
2472         break;
2473     }
2474
2475     ASSERT_NOT_REACHED();
2476     return TAUTO;
2477 }
2478
2479 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETextAlign e)
2480     : CSSValue(PrimitiveClass)
2481 {
2482     m_primitiveUnitType = CSS_VALUE_ID;
2483     switch (e) {
2484     case TASTART:
2485         m_value.valueID = CSSValueStart;
2486         break;
2487     case TAEND:
2488         m_value.valueID = CSSValueEnd;
2489         break;
2490     case LEFT:
2491         m_value.valueID = CSSValueLeft;
2492         break;
2493     case RIGHT:
2494         m_value.valueID = CSSValueRight;
2495         break;
2496     case CENTER:
2497         m_value.valueID = CSSValueCenter;
2498         break;
2499     case JUSTIFY:
2500         m_value.valueID = CSSValueJustify;
2501         break;
2502     case WEBKIT_LEFT:
2503         m_value.valueID = CSSValueWebkitLeft;
2504         break;
2505     case WEBKIT_RIGHT:
2506         m_value.valueID = CSSValueWebkitRight;
2507         break;
2508     case WEBKIT_CENTER:
2509         m_value.valueID = CSSValueWebkitCenter;
2510         break;
2511     }
2512 }
2513
2514 template<> inline CSSPrimitiveValue::operator ETextAlign() const
2515 {
2516     ASSERT(isValueID());
2517
2518     switch (m_value.valueID) {
2519     case CSSValueWebkitAuto: // Legacy -webkit-auto. Eqiuvalent to start.
2520     case CSSValueStart:
2521         return TASTART;
2522     case CSSValueEnd:
2523         return TAEND;
2524     default:
2525         return static_cast<ETextAlign>(m_value.valueID - CSSValueLeft);
2526     }
2527 }
2528
2529 #if ENABLE(CSS3_TEXT)
2530 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextAlignLast e)
2531     : CSSValue(PrimitiveClass)
2532 {
2533     m_primitiveUnitType = CSS_VALUE_ID;
2534     switch (e) {
2535     case TextAlignLastStart:
2536         m_value.valueID = CSSValueStart;
2537         break;
2538     case TextAlignLastEnd:
2539         m_value.valueID = CSSValueEnd;
2540         break;
2541     case TextAlignLastLeft:
2542         m_value.valueID = CSSValueLeft;
2543         break;
2544     case TextAlignLastRight:
2545         m_value.valueID = CSSValueRight;
2546         break;
2547     case TextAlignLastCenter:
2548         m_value.valueID = CSSValueCenter;
2549         break;
2550     case TextAlignLastJustify:
2551         m_value.valueID = CSSValueJustify;
2552         break;
2553     case TextAlignLastAuto:
2554         m_value.valueID = CSSValueAuto;
2555         break;
2556     }
2557 }
2558
2559 template<> inline CSSPrimitiveValue::operator TextAlignLast() const
2560 {
2561     ASSERT(isValueID());
2562
2563     switch (m_value.valueID) {
2564     case CSSValueAuto:
2565         return TextAlignLastAuto;
2566     case CSSValueStart:
2567         return TextAlignLastStart;
2568     case CSSValueEnd:
2569         return TextAlignLastEnd;
2570     case CSSValueLeft:
2571         return TextAlignLastLeft;
2572     case CSSValueRight:
2573         return TextAlignLastRight;
2574     case CSSValueCenter:
2575         return TextAlignLastCenter;
2576     case CSSValueJustify:
2577         return TextAlignLastJustify;
2578     default:
2579         break;
2580     }
2581
2582     ASSERT_NOT_REACHED();
2583     return TextAlignLastAuto;
2584 }
2585
2586 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextJustify e)
2587     : CSSValue(PrimitiveClass)
2588 {
2589     m_primitiveUnitType = CSS_VALUE_ID;
2590     switch (e) {
2591     case TextJustifyAuto:
2592         m_value.valueID = CSSValueAuto;
2593         break;
2594     case TextJustifyNone:
2595         m_value.valueID = CSSValueNone;
2596         break;
2597     case TextJustifyInterWord:
2598         m_value.valueID = CSSValueInterWord;
2599         break;
2600     case TextJustifyDistribute:
2601         m_value.valueID = CSSValueDistribute;
2602         break;
2603     }
2604 }
2605
2606 template<> inline CSSPrimitiveValue::operator TextJustify() const
2607 {
2608     ASSERT(isValueID());
2609
2610     switch (m_value.valueID) {
2611     case CSSValueAuto:
2612         return TextJustifyAuto;
2613     case CSSValueNone:
2614         return TextJustifyNone;
2615     case CSSValueInterWord:
2616         return TextJustifyInterWord;
2617     case CSSValueDistribute:
2618         return TextJustifyDistribute;
2619     default:
2620         break;
2621     }
2622
2623     ASSERT_NOT_REACHED();
2624     return TextJustifyAuto;
2625 }
2626 #endif // CSS3_TEXT
2627
2628 template<> inline CSSPrimitiveValue::operator TextDecoration() const
2629 {
2630     ASSERT(isValueID());
2631
2632     switch (m_value.valueID) {
2633     case CSSValueNone:
2634         return TextDecorationNone;
2635     case CSSValueUnderline:
2636         return TextDecorationUnderline;
2637     case CSSValueOverline:
2638         return TextDecorationOverline;
2639     case CSSValueLineThrough:
2640         return TextDecorationLineThrough;
2641     case CSSValueBlink:
2642         return TextDecorationBlink;
2643 #if ENABLE(LETTERPRESS)
2644     case CSSValueWebkitLetterpress:
2645         return TextDecorationLetterpress;
2646 #endif
2647     default:
2648         break;
2649     }
2650
2651     ASSERT_NOT_REACHED();
2652     return TextDecorationNone;
2653 }
2654
2655 template<> inline CSSPrimitiveValue::operator TextDecorationStyle() const
2656 {
2657     ASSERT(isValueID());
2658
2659     switch (m_value.valueID) {
2660     case CSSValueSolid:
2661         return TextDecorationStyleSolid;
2662     case CSSValueDouble:
2663         return TextDecorationStyleDouble;
2664     case CSSValueDotted:
2665         return TextDecorationStyleDotted;
2666     case CSSValueDashed:
2667         return TextDecorationStyleDashed;
2668     case CSSValueWavy:
2669         return TextDecorationStyleWavy;
2670     default:
2671         break;
2672     }
2673
2674     ASSERT_NOT_REACHED();
2675     return TextDecorationStyleSolid;
2676 }
2677
2678 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextUnderlinePosition e)
2679     : CSSValue(PrimitiveClass)
2680 {
2681     m_primitiveUnitType = CSS_VALUE_ID;
2682     switch (e) {
2683     case TextUnderlinePositionAuto:
2684         m_value.valueID = CSSValueAuto;
2685         break;
2686     case TextUnderlinePositionAlphabetic:
2687         m_value.valueID = CSSValueAlphabetic;
2688         break;
2689     case TextUnderlinePositionUnder:
2690         m_value.valueID = CSSValueUnder;
2691         break;
2692     }
2693
2694     // FIXME: Implement support for 'under left' and 'under right' values.
2695 }
2696
2697 template<> inline CSSPrimitiveValue::operator TextUnderlinePosition() const
2698 {
2699     ASSERT(isValueID());
2700
2701     switch (m_value.valueID) {
2702     case CSSValueAuto:
2703         return TextUnderlinePositionAuto;
2704     case CSSValueAlphabetic:
2705         return TextUnderlinePositionAlphabetic;
2706     case CSSValueUnder:
2707         return TextUnderlinePositionUnder;
2708     default:
2709         break;
2710     }
2711
2712     // FIXME: Implement support for 'under left' and 'under right' values.
2713
2714     ASSERT_NOT_REACHED();
2715     return TextUnderlinePositionAuto;
2716 }
2717
2718 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETextSecurity e)
2719     : CSSValue(PrimitiveClass)
2720 {
2721     m_primitiveUnitType = CSS_VALUE_ID;
2722     switch (e) {
2723     case TSNONE:
2724         m_value.valueID = CSSValueNone;
2725         break;
2726     case TSDISC:
2727         m_value.valueID = CSSValueDisc;
2728         break;
2729     case TSCIRCLE:
2730         m_value.valueID = CSSValueCircle;
2731         break;
2732     case TSSQUARE:
2733         m_value.valueID = CSSValueSquare;
2734         break;
2735     }
2736 }
2737
2738 template<> inline CSSPrimitiveValue::operator ETextSecurity() const
2739 {
2740     ASSERT(isValueID());
2741
2742     switch (m_value.valueID) {
2743     case CSSValueNone:
2744         return TSNONE;
2745     case CSSValueDisc:
2746         return TSDISC;
2747     case CSSValueCircle:
2748         return TSCIRCLE;
2749     case CSSValueSquare:
2750         return TSSQUARE;
2751     default:
2752         break;
2753     }
2754
2755     ASSERT_NOT_REACHED();
2756     return TSNONE;
2757 }
2758
2759 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETextTransform e)
2760     : CSSValue(PrimitiveClass)
2761 {
2762     m_primitiveUnitType = CSS_VALUE_ID;
2763     switch (e) {
2764     case CAPITALIZE:
2765         m_value.valueID = CSSValueCapitalize;
2766         break;
2767     case UPPERCASE:
2768         m_value.valueID = CSSValueUppercase;
2769         break;
2770     case LOWERCASE:
2771         m_value.valueID = CSSValueLowercase;
2772         break;
2773     case TTNONE:
2774         m_value.valueID = CSSValueNone;
2775         break;
2776     }
2777 }
2778
2779 template<> inline CSSPrimitiveValue::operator ETextTransform() const
2780 {
2781     ASSERT(isValueID());
2782
2783     switch (m_value.valueID) {
2784     case CSSValueCapitalize:
2785         return CAPITALIZE;
2786     case CSSValueUppercase:
2787         return UPPERCASE;
2788     case CSSValueLowercase:
2789         return LOWERCASE;
2790     case CSSValueNone:
2791         return TTNONE;
2792     default:
2793         break;
2794     }
2795
2796     ASSERT_NOT_REACHED();
2797     return TTNONE;
2798 }
2799
2800 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUnicodeBidi e)
2801     : CSSValue(PrimitiveClass)
2802 {
2803     m_primitiveUnitType = CSS_VALUE_ID;
2804     switch (e) {
2805     case UBNormal:
2806         m_value.valueID = CSSValueNormal;
2807         break;
2808     case Embed:
2809         m_value.valueID = CSSValueEmbed;
2810         break;
2811     case Override:
2812         m_value.valueID = CSSValueBidiOverride;
2813         break;
2814     case Isolate:
2815         m_value.valueID = CSSValueIsolate;
2816         break;
2817     case IsolateOverride:
2818         m_value.valueID = CSSValueIsolateOverride;
2819         break;
2820     case Plaintext:
2821         m_value.valueID = CSSValuePlaintext;
2822         break;
2823     }
2824 }
2825
2826 template<> inline CSSPrimitiveValue::operator EUnicodeBidi() const
2827 {
2828     ASSERT(isValueID());
2829
2830     switch (m_value.valueID) {
2831     case CSSValueNormal:
2832         return UBNormal;
2833     case CSSValueEmbed:
2834         return Embed;
2835     case CSSValueBidiOverride:
2836         return Override;
2837     case CSSValueIsolate:
2838     case CSSValueWebkitIsolate:
2839         return Isolate;
2840     case CSSValueIsolateOverride:
2841     case CSSValueWebkitIsolateOverride:
2842         return IsolateOverride;
2843     case CSSValuePlaintext:
2844     case CSSValueWebkitPlaintext:
2845         return Plaintext;
2846     default:
2847         break;
2848     }
2849
2850     ASSERT_NOT_REACHED();
2851     return UBNormal;
2852 }
2853
2854 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUserDrag e)
2855     : CSSValue(PrimitiveClass)
2856 {
2857     m_primitiveUnitType = CSS_VALUE_ID;
2858     switch (e) {
2859     case DRAG_AUTO:
2860         m_value.valueID = CSSValueAuto;
2861         break;
2862     case DRAG_NONE:
2863         m_value.valueID = CSSValueNone;
2864         break;
2865     case DRAG_ELEMENT:
2866         m_value.valueID = CSSValueElement;
2867         break;
2868     default:
2869         break;
2870     }
2871 }
2872
2873 template<> inline CSSPrimitiveValue::operator EUserDrag() const
2874 {
2875     ASSERT(isValueID());
2876
2877     switch (m_value.valueID) {
2878     case CSSValueAuto:
2879         return DRAG_AUTO;
2880     case CSSValueNone:
2881         return DRAG_NONE;
2882     case CSSValueElement:
2883         return DRAG_ELEMENT;
2884     default:
2885         break;
2886     }
2887
2888     ASSERT_NOT_REACHED();
2889     return DRAG_AUTO;
2890 }
2891
2892 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUserModify e)
2893     : CSSValue(PrimitiveClass)
2894 {
2895     m_primitiveUnitType = CSS_VALUE_ID;
2896     switch (e) {
2897     case READ_ONLY:
2898         m_value.valueID = CSSValueReadOnly;
2899         break;
2900     case READ_WRITE:
2901         m_value.valueID = CSSValueReadWrite;
2902         break;
2903     case READ_WRITE_PLAINTEXT_ONLY:
2904         m_value.valueID = CSSValueReadWritePlaintextOnly;
2905         break;
2906     }
2907 }
2908
2909 template<> inline CSSPrimitiveValue::operator EUserModify() const
2910 {
2911     ASSERT(isValueID());
2912
2913     switch (m_value.valueID) {
2914     case CSSValueReadOnly:
2915         return READ_ONLY;
2916     case CSSValueReadWrite:
2917         return READ_WRITE;
2918     case CSSValueReadWritePlaintextOnly:
2919         return READ_WRITE_PLAINTEXT_ONLY;
2920     default:
2921         break;
2922     }
2923
2924     ASSERT_NOT_REACHED();
2925     return READ_ONLY;
2926 }
2927
2928 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUserSelect e)
2929     : CSSValue(PrimitiveClass)
2930 {
2931     m_primitiveUnitType = CSS_VALUE_ID;
2932     switch (e) {
2933     case SELECT_NONE:
2934         m_value.valueID = CSSValueNone;
2935         break;
2936     case SELECT_TEXT:
2937         m_value.valueID = CSSValueText;
2938         break;
2939     case SELECT_ALL:
2940         m_value.valueID = CSSValueAll;
2941         break;
2942     }
2943 }
2944
2945 template<> inline CSSPrimitiveValue::operator EUserSelect() const
2946 {
2947     ASSERT(isValueID());
2948
2949     switch (m_value.valueID) {
2950     case CSSValueAuto:
2951         return SELECT_TEXT;
2952     case CSSValueNone:
2953         return SELECT_NONE;
2954     case CSSValueText:
2955         return SELECT_TEXT;
2956     case CSSValueAll:
2957         return SELECT_ALL;
2958     default:
2959         break;
2960     }
2961
2962     ASSERT_NOT_REACHED();
2963     return SELECT_TEXT;
2964 }
2965
2966 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EVerticalAlign a)
2967     : CSSValue(PrimitiveClass)
2968 {
2969     m_primitiveUnitType = CSS_VALUE_ID;
2970     switch (a) {
2971     case TOP:
2972         m_value.valueID = CSSValueTop;
2973         break;
2974     case BOTTOM:
2975         m_value.valueID = CSSValueBottom;
2976         break;
2977     case MIDDLE:
2978         m_value.valueID = CSSValueMiddle;
2979         break;
2980     case BASELINE:
2981         m_value.valueID = CSSValueBaseline;
2982         break;
2983     case TEXT_BOTTOM:
2984         m_value.valueID = CSSValueTextBottom;
2985         break;
2986     case TEXT_TOP:
2987         m_value.valueID = CSSValueTextTop;
2988         break;
2989     case SUB:
2990         m_value.valueID = CSSValueSub;
2991         break;
2992     case SUPER:
2993         m_value.valueID = CSSValueSuper;
2994         break;
2995     case BASELINE_MIDDLE:
2996         m_value.valueID = CSSValueWebkitBaselineMiddle;
2997         break;
2998     case LENGTH:
2999         m_value.valueID = CSSValueInvalid;
3000     }
3001 }
3002
3003 template<> inline CSSPrimitiveValue::operator EVerticalAlign() const
3004 {
3005     ASSERT(isValueID());
3006
3007     switch (m_value.valueID) {
3008     case CSSValueTop:
3009         return TOP;
3010     case CSSValueBottom:
3011         return BOTTOM;
3012     case CSSValueMiddle:
3013         return MIDDLE;
3014     case CSSValueBaseline:
3015         return BASELINE;
3016     case CSSValueTextBottom:
3017         return TEXT_BOTTOM;
3018     case CSSValueTextTop:
3019         return TEXT_TOP;
3020     case CSSValueSub:
3021         return SUB;
3022     case CSSValueSuper:
3023         return SUPER;
3024     case CSSValueWebkitBaselineMiddle:
3025         return BASELINE_MIDDLE;
3026     default:
3027         break;
3028     }
3029
3030     ASSERT_NOT_REACHED();
3031     return TOP;
3032 }
3033
3034 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EVisibility e)
3035     : CSSValue(PrimitiveClass)
3036 {
3037     m_primitiveUnitType = CSS_VALUE_ID;
3038     switch (e) {
3039     case VISIBLE:
3040         m_value.valueID = CSSValueVisible;
3041         break;
3042     case HIDDEN:
3043         m_value.valueID = CSSValueHidden;
3044         break;
3045     case COLLAPSE:
3046         m_value.valueID = CSSValueCollapse;
3047         break;
3048     }
3049 }
3050
3051 template<> inline CSSPrimitiveValue::operator EVisibility() const
3052 {
3053     ASSERT(isValueID());
3054
3055     switch (m_value.valueID) {
3056     case CSSValueHidden:
3057         return HIDDEN;
3058     case CSSValueVisible:
3059         return VISIBLE;
3060     case CSSValueCollapse:
3061         return COLLAPSE;
3062     default:
3063         break;
3064     }
3065
3066     ASSERT_NOT_REACHED();
3067     return VISIBLE;
3068 }
3069
3070 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EWhiteSpace e)
3071     : CSSValue(PrimitiveClass)
3072 {
3073     m_primitiveUnitType = CSS_VALUE_ID;
3074     switch (e) {
3075     case NORMAL:
3076         m_value.valueID = CSSValueNormal;
3077         break;
3078     case PRE:
3079         m_value.valueID = CSSValuePre;
3080         break;
3081     case PRE_WRAP:
3082         m_value.valueID = CSSValuePreWrap;
3083         break;
3084     case PRE_LINE:
3085         m_value.valueID = CSSValuePreLine;
3086         break;
3087     case NOWRAP:
3088         m_value.valueID = CSSValueNowrap;
3089         break;
3090     case KHTML_NOWRAP:
3091         m_value.valueID = CSSValueWebkitNowrap;
3092         break;
3093     }
3094 }
3095
3096 template<> inline CSSPrimitiveValue::operator EWhiteSpace() const
3097 {
3098     ASSERT(isValueID());
3099
3100     switch (m_value.valueID) {
3101     case CSSValueWebkitNowrap:
3102         return KHTML_NOWRAP;
3103     case CSSValueNowrap:
3104         return NOWRAP;
3105     case CSSValuePre:
3106         return PRE;
3107     case CSSValuePreWrap:
3108         return PRE_WRAP;
3109     case CSSValuePreLine:
3110         return PRE_LINE;
3111     case CSSValueNormal:
3112         return NORMAL;
3113     default:
3114         break;
3115     }
3116
3117     ASSERT_NOT_REACHED();
3118     return NORMAL;
3119 }
3120
3121 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EWordBreak e)
3122     : CSSValue(PrimitiveClass)
3123 {
3124     m_primitiveUnitType = CSS_VALUE_ID;
3125     switch (e) {
3126     case NormalWordBreak:
3127         m_value.valueID = CSSValueNormal;
3128         break;
3129     case BreakAllWordBreak:
3130         m_value.valueID = CSSValueBreakAll;
3131         break;
3132     case KeepAllWordBreak:
3133         m_value.valueID = CSSValueKeepAll;
3134         break;
3135     case BreakWordBreak:
3136         m_value.valueID = CSSValueBreakWord;
3137         break;
3138     }
3139 }
3140
3141 template<> inline CSSPrimitiveValue::operator EWordBreak() const
3142 {
3143     ASSERT(isValueID());
3144
3145     switch (m_value.valueID) {
3146     case CSSValueBreakAll:
3147         return BreakAllWordBreak;
3148     case CSSValueKeepAll:
3149         return KeepAllWordBreak;
3150     case CSSValueBreakWord:
3151         return BreakWordBreak;
3152     case CSSValueNormal:
3153         return NormalWordBreak;
3154     default:
3155         break;
3156     }
3157
3158     ASSERT_NOT_REACHED();
3159     return NormalWordBreak;
3160 }
3161
3162 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EOverflowWrap e)
3163     : CSSValue(PrimitiveClass)
3164 {
3165     m_primitiveUnitType = CSS_VALUE_ID;
3166     switch (e) {
3167     case NormalOverflowWrap:
3168         m_value.valueID = CSSValueNormal;
3169         break;
3170     case BreakOverflowWrap:
3171         m_value.valueID = CSSValueBreakWord;
3172         break;
3173     }
3174 }
3175
3176 template<> inline CSSPrimitiveValue::operator EOverflowWrap() const
3177 {
3178     ASSERT(isValueID());
3179
3180     switch (m_value.valueID) {
3181     case CSSValueBreakWord:
3182         return BreakOverflowWrap;
3183     case CSSValueNormal:
3184         return NormalOverflowWrap;
3185     default:
3186         break;
3187     }
3188
3189     ASSERT_NOT_REACHED();
3190     return NormalOverflowWrap;
3191 }
3192
3193 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextDirection e)
3194     : CSSValue(PrimitiveClass)
3195 {
3196     m_primitiveUnitType = CSS_VALUE_ID;
3197     switch (e) {
3198     case LTR:
3199         m_value.valueID = CSSValueLtr;
3200         break;
3201     case RTL:
3202         m_value.valueID = CSSValueRtl;
3203         break;
3204     }
3205 }
3206
3207 template<> inline CSSPrimitiveValue::operator TextDirection() const
3208 {
3209     ASSERT(isValueID());
3210
3211     switch (m_value.valueID) {
3212     case CSSValueLtr:
3213         return LTR;
3214     case CSSValueRtl:
3215         return RTL;
3216     default:
3217         break;
3218     }
3219
3220     ASSERT_NOT_REACHED();
3221     return LTR;
3222 }
3223
3224 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(WritingMode e)
3225     : CSSValue(PrimitiveClass)
3226 {
3227     m_primitiveUnitType = CSS_VALUE_ID;
3228     switch (e) {
3229     case TopToBottomWritingMode:
3230         m_value.valueID = CSSValueHorizontalTb;
3231         break;
3232     case RightToLeftWritingMode:
3233         m_value.valueID = CSSValueVerticalRl;
3234         break;
3235     case LeftToRightWritingMode:
3236         m_value.valueID = CSSValueVerticalLr;
3237         break;
3238     case BottomToTopWritingMode:
3239         m_value.valueID = CSSValueHorizontalBt;
3240         break;
3241     }
3242 }
3243
3244 template<> inline CSSPrimitiveValue::operator WritingMode() const
3245 {
3246     ASSERT(isValueID());
3247
3248     switch (m_value.valueID) {
3249     case CSSValueHorizontalTb:
3250     case CSSValueLrTb:
3251     case CSSValueRl:
3252     case CSSValueRlTb:
3253         return TopToBottomWritingMode;
3254     case CSSValueVerticalRl:
3255     case CSSValueTb:
3256     case CSSValueTbRl:
3257         return RightToLeftWritingMode;
3258     case CSSValueVerticalLr:
3259         return LeftToRightWritingMode;
3260     case CSSValueHorizontalBt:
3261         return BottomToTopWritingMode;
3262     default:
3263         break;
3264     }
3265
3266     ASSERT_NOT_REACHED();
3267     return TopToBottomWritingMode;
3268 }
3269
3270 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextCombine e)
3271     : CSSValue(PrimitiveClass)
3272 {
3273     m_primitiveUnitType = CSS_VALUE_ID;
3274     switch (e) {
3275     case TextCombineNone:
3276         m_value.valueID = CSSValueNone;
3277         break;
3278     case TextCombineHorizontal:
3279         m_value.valueID = CSSValueHorizontal;
3280         break;
3281     }
3282 }
3283
3284 template<> inline CSSPrimitiveValue::operator TextCombine() const
3285 {
3286     ASSERT(isValueID());
3287
3288     switch (m_value.valueID) {
3289     case CSSValueNone:
3290         return TextCombineNone;
3291     case CSSValueHorizontal:
3292         return TextCombineHorizontal;
3293     default:
3294         break;
3295     }
3296
3297     ASSERT_NOT_REACHED();
3298     return TextCombineNone;
3299 }
3300
3301 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(RubyPosition position)
3302     : CSSValue(PrimitiveClass)
3303 {
3304     m_primitiveUnitType = CSS_VALUE_ID;
3305     switch (position) {
3306     case RubyPositionBefore:
3307         m_value.valueID = CSSValueBefore;
3308         break;
3309     case RubyPositionAfter:
3310         m_value.valueID = CSSValueAfter;
3311         break;
3312     case RubyPositionInterCharacter:
3313         m_value.valueID = CSSValueInterCharacter;
3314         break;
3315     }
3316 }
3317
3318 template<> inline CSSPrimitiveValue::operator RubyPosition() const
3319 {
3320     ASSERT(isValueID());
3321
3322     switch (m_value.valueID) {
3323     case CSSValueBefore:
3324         return RubyPositionBefore;
3325     case CSSValueAfter:
3326         return RubyPositionAfter;
3327     case CSSValueInterCharacter:
3328         return RubyPositionInterCharacter;
3329     default:
3330         break;
3331     }
3332
3333     ASSERT_NOT_REACHED();
3334     return RubyPositionBefore;
3335 }
3336
3337 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextOverflow overflow)
3338     : CSSValue(PrimitiveClass)
3339 {
3340     m_primitiveUnitType = CSS_VALUE_ID;
3341     switch (overflow) {
3342     case TextOverflowClip:
3343         m_value.valueID = CSSValueClip;
3344         break;
3345     case TextOverflowEllipsis:
3346         m_value.valueID = CSSValueEllipsis;
3347         break;
3348     }
3349 }
3350
3351 template<> inline CSSPrimitiveValue::operator TextOverflow() const
3352 {
3353     ASSERT(isValueID());
3354
3355     switch (m_value.valueID) {
3356     case CSSValueClip:
3357         return TextOverflowClip;
3358     case CSSValueEllipsis:
3359         return TextOverflowEllipsis;
3360     default:
3361         break;
3362     }
3363
3364     ASSERT_NOT_REACHED();
3365     return TextOverflowClip;
3366 }
3367
3368 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextEmphasisFill fill)
3369     : CSSValue(PrimitiveClass)
3370 {
3371     m_primitiveUnitType = CSS_VALUE_ID;
3372     switch (fill) {
3373     case TextEmphasisFillFilled:
3374         m_value.valueID = CSSValueFilled;
3375         break;
3376     case TextEmphasisFillOpen:
3377         m_value.valueID = CSSValueOpen;
3378         break;
3379     }
3380 }
3381
3382 template<> inline CSSPrimitiveValue::operator TextEmphasisFill() const
3383 {
3384     ASSERT(isValueID());
3385
3386     switch (m_value.valueID) {
3387     case CSSValueFilled:
3388         return TextEmphasisFillFilled;
3389     case CSSValueOpen:
3390         return TextEmphasisFillOpen;
3391     default:
3392         break;
3393     }
3394
3395     ASSERT_NOT_REACHED();
3396     return TextEmphasisFillFilled;
3397 }
3398
3399 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextEmphasisMark mark)
3400     : CSSValue(PrimitiveClass)
3401 {
3402     m_primitiveUnitType = CSS_VALUE_ID;
3403     switch (mark) {
3404     case TextEmphasisMarkDot:
3405         m_value.valueID = CSSValueDot;
3406         break;
3407     case TextEmphasisMarkCircle:
3408         m_value.valueID = CSSValueCircle;
3409         break;
3410     case TextEmphasisMarkDoubleCircle:
3411         m_value.valueID = CSSValueDoubleCircle;
3412         break;
3413     case TextEmphasisMarkTriangle:
3414         m_value.valueID = CSSValueTriangle;
3415         break;
3416     case TextEmphasisMarkSesame:
3417         m_value.valueID = CSSValueSesame;
3418         break;
3419     case TextEmphasisMarkNone:
3420     case TextEmphasisMarkAuto:
3421     case TextEmphasisMarkCustom:
3422         ASSERT_NOT_REACHED();
3423         m_value.valueID = CSSValueNone;
3424         break;
3425     }
3426 }
3427
3428 template<> inline CSSPrimitiveValue::operator TextEmphasisMark() const
3429 {
3430     ASSERT(isValueID());
3431
3432     switch (m_value.valueID) {
3433     case CSSValueNone:
3434         return TextEmphasisMarkNone;
3435     case CSSValueDot:
3436         return TextEmphasisMarkDot;
3437     case CSSValueCircle:
3438         return TextEmphasisMarkCircle;
3439     case CSSValueDoubleCircle:
3440         return TextEmphasisMarkDoubleCircle;
3441     case CSSValueTriangle:
3442         return TextEmphasisMarkTriangle;
3443     case CSSValueSesame:
3444         return TextEmphasisMarkSesame;
3445     default:
3446         break;
3447     }
3448
3449     ASSERT_NOT_REACHED();
3450     return TextEmphasisMarkNone;
3451 }
3452
3453 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextOrientation e)
3454     : CSSValue(PrimitiveClass)
3455 {
3456     m_primitiveUnitType = CSS_VALUE_ID;
3457     switch (e) {
3458     case TextOrientation::Sideways:
3459         m_value.valueID = CSSValueSideways;
3460         break;
3461     case TextOrientation::Mixed:
3462         m_value.valueID = CSSValueMixed;
3463         break;
3464     case TextOrientation::Upright:
3465         m_value.valueID = CSSValueUpright;
3466         break;
3467     }
3468 }
3469
3470 template<> inline CSSPrimitiveValue::operator TextOrientation() const
3471 {
3472     ASSERT(isValueID());
3473
3474     switch (m_value.valueID) {
3475     case CSSValueSideways:
3476         return TextOrientation::Sideways;
3477     case CSSValueSidewaysRight:
3478         return TextOrientation::Sideways;
3479     case CSSValueVerticalRight:
3480         return TextOrientation::Mixed;
3481     case CSSValueMixed:
3482         return TextOrientation::Mixed;
3483     case CSSValueUpright:
3484         return TextOrientation::Upright;
3485     default:
3486         break;
3487     }
3488
3489     ASSERT_NOT_REACHED();
3490     return TextOrientation::Mixed;
3491 }
3492
3493 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EPointerEvents e)
3494     : CSSValue(PrimitiveClass)
3495 {
3496     m_primitiveUnitType = CSS_VALUE_ID;
3497     switch (e) {
3498     case PE_NONE:
3499         m_value.valueID = CSSValueNone;
3500         break;
3501     case PE_STROKE:
3502         m_value.valueID = CSSValueStroke;
3503         break;
3504     case PE_FILL:
3505         m_value.valueID = CSSValueFill;
3506         break;
3507     case PE_PAINTED:
3508         m_value.valueID = CSSValuePainted;
3509         break;
3510     case PE_VISIBLE:
3511         m_value.valueID = CSSValueVisible;
3512         break;
3513     case PE_VISIBLE_STROKE:
3514         m_value.valueID = CSSValueVisibleStroke;
3515         break;
3516     case PE_VISIBLE_FILL:
3517         m_value.valueID = CSSValueVisibleFill;
3518         break;
3519     case PE_VISIBLE_PAINTED:
3520         m_value.valueID = CSSValueVisiblePainted;
3521         break;
3522     case PE_AUTO:
3523         m_value.valueID = CSSValueAuto;
3524         break;
3525     case PE_ALL:
3526         m_value.valueID = CSSValueAll;
3527         break;
3528     }
3529 }
3530
3531 template<> inline CSSPrimitiveValue::operator EPointerEvents() const
3532 {
3533     ASSERT(isValueID());
3534
3535     switch (m_value.valueID) {
3536     case CSSValueAll:
3537         return PE_ALL;
3538     case CSSValueAuto:
3539         return PE_AUTO;
3540     case CSSValueNone:
3541         return PE_NONE;
3542     case CSSValueVisiblePainted:
3543         return PE_VISIBLE_PAINTED;
3544     case CSSValueVisibleFill:
3545         return PE_VISIBLE_FILL;
3546     case CSSValueVisibleStroke:
3547         return PE_VISIBLE_STROKE;
3548     case CSSValueVisible:
3549         return PE_VISIBLE;
3550     case CSSValuePainted:
3551         return PE_PAINTED;
3552     case CSSValueFill:
3553         return PE_FILL;
3554     case CSSValueStroke:
3555         return PE_STROKE;
3556     default:
3557         break;
3558     }
3559
3560     ASSERT_NOT_REACHED();
3561     return PE_ALL;
3562 }
3563
3564 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(Kerning kerning)
3565     : CSSValue(PrimitiveClass)
3566 {
3567     m_primitiveUnitType = CSS_VALUE_ID;
3568     switch (kerning) {
3569     case Kerning::Auto:
3570         m_value.valueID = CSSValueAuto;
3571         return;
3572     case Kerning::Normal:
3573         m_value.valueID = CSSValueNormal;
3574         return;
3575     case Kerning::NoShift:
3576         m_value.valueID = CSSValueNone;
3577         return;
3578     }
3579
3580     ASSERT_NOT_REACHED();
3581     m_value.valueID = CSSValueAuto;
3582 }
3583
3584 template<> inline CSSPrimitiveValue::operator Kerning() const
3585 {
3586     ASSERT(isValueID());
3587
3588     switch (m_value.valueID) {
3589     case CSSValueAuto:
3590         return Kerning::Auto;
3591     case CSSValueNormal:
3592         return Kerning::Normal;
3593     case CSSValueNone:
3594         return Kerning::NoShift;
3595     default:
3596         break;
3597     }
3598
3599     ASSERT_NOT_REACHED();
3600     return Kerning::Auto;
3601 }
3602
3603 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ObjectFit fit)
3604     : CSSValue(PrimitiveClass)
3605 {
3606     m_primitiveUnitType = CSS_VALUE_ID;
3607     switch (fit) {
3608     case ObjectFitFill:
3609         m_value.valueID = CSSValueFill;
3610         break;
3611     case ObjectFitContain:
3612         m_value.valueID = CSSValueContain;
3613         break;
3614     case ObjectFitCover:
3615         m_value.valueID = CSSValueCover;
3616         break;
3617     case ObjectFitNone:
3618         m_value.valueID = CSSValueNone;
3619         break;
3620     case ObjectFitScaleDown:
3621         m_value.valueID = CSSValueScaleDown;
3622         break;
3623     }
3624 }
3625
3626 template<> inline CSSPrimitiveValue::operator ObjectFit() const
3627 {
3628     ASSERT(isValueID());
3629
3630     switch (m_value.valueID) {
3631     case CSSValueFill:
3632         return ObjectFitFill;
3633     case CSSValueContain:
3634         return ObjectFitContain;
3635     case CSSValueCover:
3636         return ObjectFitCover;
3637     case CSSValueNone:
3638         return ObjectFitNone;
3639     case CSSValueScaleDown:
3640         return ObjectFitScaleDown;
3641     default:
3642         ASSERT_NOT_REACHED();
3643         return ObjectFitFill;
3644     }
3645 }
3646
3647 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontSmoothingMode smoothing)
3648     : CSSValue(PrimitiveClass)
3649 {
3650     m_primitiveUnitType = CSS_VALUE_ID;
3651     switch (smoothing) {
3652     case AutoSmoothing:
3653         m_value.valueID = CSSValueAuto;
3654         return;
3655     case NoSmoothing:
3656         m_value.valueID = CSSValueNone;
3657         return;
3658     case Antialiased:
3659         m_value.valueID = CSSValueAntialiased;
3660         return;
3661     case SubpixelAntialiased:
3662         m_value.valueID = CSSValueSubpixelAntialiased;
3663         return;
3664     }
3665
3666     ASSERT_NOT_REACHED();
3667     m_value.valueID = CSSValueAuto;
3668 }
3669
3670 template<> inline CSSPrimitiveValue::operator FontSmoothingMode() const
3671 {
3672     ASSERT(isValueID());
3673
3674     switch (m_value.valueID) {
3675     case CSSValueAuto:
3676         return AutoSmoothing;
3677     case CSSValueNone:
3678         return NoSmoothing;
3679     case CSSValueAntialiased:
3680         return Antialiased;
3681     case CSSValueSubpixelAntialiased:
3682         return SubpixelAntialiased;
3683     default:
3684         break;
3685     }
3686
3687     ASSERT_NOT_REACHED();
3688     return AutoSmoothing;
3689 }
3690
3691 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontSmallCaps smallCaps)
3692     : CSSValue(PrimitiveClass)
3693 {
3694     m_primitiveUnitType = CSS_VALUE_ID;
3695     switch (smallCaps) {
3696     case FontSmallCapsOff:
3697         m_value.valueID = CSSValueNormal;
3698         return;
3699     case FontSmallCapsOn:
3700         m_value.valueID = CSSValueSmallCaps;
3701         return;
3702     }
3703
3704     ASSERT_NOT_REACHED();
3705     m_value.valueID = CSSValueNormal;
3706 }
3707
3708 template<> inline CSSPrimitiveValue::operator FontSmallCaps() const
3709 {
3710     ASSERT(isValueID());
3711
3712     switch (m_value.valueID) {
3713     case CSSValueSmallCaps:
3714         return FontSmallCapsOn;
3715     case CSSValueNormal:
3716         return FontSmallCapsOff;
3717     default:
3718         break;
3719     }
3720     ASSERT_NOT_REACHED();
3721     return FontSmallCapsOff;
3722 }
3723
3724 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextRenderingMode e)
3725     : CSSValue(PrimitiveClass)
3726 {
3727     m_primitiveUnitType = CSS_VALUE_ID;
3728     switch (e) {
3729     case AutoTextRendering:
3730         m_value.valueID = CSSValueAuto;
3731         break;
3732     case OptimizeSpeed:
3733         m_value.valueID = CSSValueOptimizeSpeed;
3734         break;
3735     case OptimizeLegibility:
3736         m_value.valueID = CSSValueOptimizeLegibility;
3737         break;
3738     case GeometricPrecision:
3739         m_value.valueID = CSSValueGeometricPrecision;
3740         break;
3741     }
3742 }
3743
3744 template<> inline CSSPrimitiveValue::operator TextRenderingMode() const
3745 {
3746     ASSERT(isValueID());
3747
3748     switch (m_value.valueID) {
3749     case CSSValueAuto:
3750         return AutoTextRendering;
3751     case CSSValueOptimizeSpeed:
3752         return OptimizeSpeed;
3753     case CSSValueOptimizeLegibility:
3754         return OptimizeLegibility;
3755     case CSSValueGeometricPrecision:
3756         return GeometricPrecision;
3757     default:
3758         break;
3759     }
3760
3761     ASSERT_NOT_REACHED();
3762     return AutoTextRendering;
3763 }
3764
3765 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(Hyphens hyphens)
3766     : CSSValue(PrimitiveClass)
3767 {
3768     m_primitiveUnitType = CSS_VALUE_ID;
3769     switch (hyphens) {
3770     case HyphensNone:
3771         m_value.valueID = CSSValueNone;
3772         break;
3773     case HyphensManual:
3774         m_value.valueID = CSSValueManual;
3775         break;
3776     case HyphensAuto:
3777         m_value.valueID = CSSValueAuto;
3778         break;
3779     }
3780 }
3781
3782 template<> inline CSSPrimitiveValue::operator Hyphens() const
3783 {
3784     ASSERT(isValueID());
3785
3786     switch (m_value.valueID) {
3787     case CSSValueNone:
3788         return HyphensNone;
3789     case CSSValueManual:
3790         return HyphensManual;
3791     case CSSValueAuto:
3792         return HyphensAuto;
3793     default:
3794         break;
3795     }
3796
3797     ASSERT_NOT_REACHED();
3798     return HyphensAuto;
3799 }
3800
3801 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineSnap gridSnap)
3802     : CSSValue(PrimitiveClass)
3803 {
3804     m_primitiveUnitType = CSS_VALUE_ID;
3805     switch (gridSnap) {
3806     case LineSnapNone:
3807         m_value.valueID = CSSValueNone;
3808         break;
3809     case LineSnapBaseline:
3810         m_value.valueID = CSSValueBaseline;
3811         break;
3812     case LineSnapContain:
3813         m_value.valueID = CSSValueContain;
3814         break;
3815     }
3816 }
3817
3818 template<> inline CSSPrimitiveValue::operator LineSnap() const
3819 {
3820     ASSERT(isValueID());
3821
3822     switch (m_value.valueID) {
3823     case CSSValueNone:
3824         return LineSnapNone;
3825     case CSSValueBaseline:
3826         return LineSnapBaseline;
3827     case CSSValueContain:
3828         return LineSnapContain;
3829     default:
3830         break;
3831     }
3832
3833     ASSERT_NOT_REACHED();
3834     return LineSnapNone;
3835 }
3836
3837 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineAlign lineAlign)
3838     : CSSValue(PrimitiveClass)
3839 {
3840     m_primitiveUnitType = CSS_VALUE_ID;
3841     switch (lineAlign) {
3842     case LineAlignNone:
3843         m_value.valueID = CSSValueNone;
3844         break;
3845     case LineAlignEdges:
3846         m_value.valueID = CSSValueEdges;
3847         break;
3848     }
3849 }
3850
3851 template<> inline CSSPrimitiveValue::operator LineAlign() const
3852 {
3853     ASSERT(isValueID());
3854
3855     switch (m_value.valueID) {
3856     case CSSValueNone:
3857         return LineAlignNone;
3858     case CSSValueEdges:
3859         return LineAlignEdges;
3860     default:
3861         break;
3862     }
3863
3864     ASSERT_NOT_REACHED();
3865     return LineAlignNone;
3866 }
3867
3868 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ESpeak e)
3869     : CSSValue(PrimitiveClass)
3870 {
3871     m_primitiveUnitType = CSS_VALUE_ID;
3872     switch (e) {
3873     case SpeakNone:
3874         m_value.valueID = CSSValueNone;
3875         break;
3876     case SpeakNormal:
3877         m_value.valueID = CSSValueNormal;
3878         break;
3879     case SpeakSpellOut:
3880         m_value.valueID = CSSValueSpellOut;
3881         break;
3882     case SpeakDigits:
3883         m_value.valueID = CSSValueDigits;
3884         break;
3885     case SpeakLiteralPunctuation:
3886         m_value.valueID = CSSValueLiteralPunctuation;
3887         break;
3888     case SpeakNoPunctuation:
3889         m_value.valueID = CSSValueNoPunctuation;
3890         break;
3891     }
3892 }
3893
3894 template<> inline CSSPrimitiveValue::operator Order() const
3895 {
3896     ASSERT(isValueID());
3897
3898     switch (m_value.valueID) {
3899     case CSSValueLogical:
3900         return LogicalOrder;
3901     case CSSValueVisual:
3902         return VisualOrder;
3903     default:
3904         break;
3905     }
3906
3907     ASSERT_NOT_REACHED();
3908     return LogicalOrder;
3909 }
3910
3911 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(Order e)
3912     : CSSValue(PrimitiveClass)
3913 {
3914     m_primitiveUnitType = CSS_VALUE_ID;
3915     switch (e) {
3916     case LogicalOrder:
3917         m_value.valueID = CSSValueLogical;
3918         break;
3919     case VisualOrder:
3920         m_value.valueID = CSSValueVisual;
3921         break;
3922     }
3923 }
3924
3925 template<> inline CSSPrimitiveValue::operator ESpeak() const
3926 {
3927     ASSERT(isValueID());
3928
3929     switch (m_value.valueID) {
3930     case CSSValueNone:
3931         return SpeakNone;
3932     case CSSValueNormal:
3933         return SpeakNormal;
3934     case CSSValueSpellOut:
3935         return SpeakSpellOut;
3936     case CSSValueDigits:
3937         return SpeakDigits;
3938     case CSSValueLiteralPunctuation:
3939         return SpeakLiteralPunctuation;
3940     case CSSValueNoPunctuation:
3941         return SpeakNoPunctuation;
3942     default:
3943         break;
3944     }
3945
3946     ASSERT_NOT_REACHED();
3947     return SpeakNormal;
3948 }
3949
3950 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(BlendMode blendMode)
3951     : CSSValue(PrimitiveClass)
3952 {
3953     m_primitiveUnitType = CSS_VALUE_ID;
3954     switch (blendMode) {
3955     case BlendModeNormal:
3956         m_value.valueID = CSSValueNormal;
3957         break;
3958     case BlendModeMultiply:
3959         m_value.valueID = CSSValueMultiply;
3960         break;
3961     case BlendModeScreen:
3962         m_value.valueID = CSSValueScreen;
3963         break;
3964     case BlendModeOverlay:
3965         m_value.valueID = CSSValueOverlay;
3966         break;
3967     case BlendModeDarken:
3968         m_value.valueID = CSSValueDarken;
3969         break;
3970     case BlendModeLighten:
3971         m_value.valueID = CSSValueLighten;
3972         break;
3973     case BlendModeColorDodge:
3974         m_value.valueID = CSSValueColorDodge;
3975         break;
3976     case BlendModeColorBurn:
3977         m_value.valueID = CSSValueColorBurn;
3978         break;
3979     case BlendModeHardLight:
3980         m_value.valueID = CSSValueHardLight;
3981         break;
3982     case BlendModeSoftLight:
3983         m_value.valueID = CSSValueSoftLight;
3984         break;
3985     case BlendModeDifference:
3986         m_value.valueID = CSSValueDifference;
3987         break;
3988     case BlendModeExclusion:
3989         m_value.valueID = CSSValueExclusion;
3990         break;
3991     case BlendModeHue:
3992         m_value.valueID = CSSValueHue;
3993         break;
3994     case BlendModeSaturation:
3995         m_value.valueID = CSSValueSaturation;
3996         break;
3997     case BlendModeColor:
3998         m_value.valueID = CSSValueColor;
3999         break;
4000     case BlendModeLuminosity:
4001         m_value.valueID = CSSValueLuminosity;
4002         break;
4003     case BlendModePlusDarker:
4004         m_value.valueID = CSSValuePlusDarker;
4005         break;
4006     case BlendModePlusLighter:
4007         m_value.valueID = CSSValuePlusLighter;
4008         break;
4009     }
4010 }
4011
4012 template<> inline CSSPrimitiveValue::operator BlendMode() const
4013 {
4014     ASSERT(isValueID());
4015
4016     switch (m_value.valueID) {
4017     case CSSValueNormal:
4018         return BlendModeNormal;
4019     case CSSValueMultiply:
4020         return BlendModeMultiply;
4021     case CSSValueScreen:
4022         return BlendModeScreen;
4023     case CSSValueOverlay:
4024         return BlendModeOverlay;
4025     case CSSValueDarken:
4026         return BlendModeDarken;
4027     case CSSValueLighten:
4028         return BlendModeLighten;
4029     case CSSValueColorDodge:
4030         return BlendModeColorDodge;
4031     case CSSValueColorBurn:
4032         return BlendModeColorBurn;
4033     case CSSValueHardLight:
4034         return BlendModeHardLight;
4035     case CSSValueSoftLight:
4036         return BlendModeSoftLight;
4037     case CSSValueDifference:
4038         return BlendModeDifference;
4039     case CSSValueExclusion:
4040         return BlendModeExclusion;
4041     case CSSValueHue:
4042         return BlendModeHue;
4043     case CSSValueSaturation:
4044         return BlendModeSaturation;
4045     case CSSValueColor:
4046         return BlendModeColor;
4047     case CSSValueLuminosity:
4048         return BlendModeLuminosity;
4049     case CSSValuePlusDarker:
4050         return BlendModePlusDarker;
4051     case CSSValuePlusLighter:
4052         return BlendModePlusLighter;
4053     default:
4054         break;
4055     }
4056
4057     ASSERT_NOT_REACHED();
4058     return BlendModeNormal;
4059 }
4060
4061 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(Isolation isolation)
4062     : CSSValue(PrimitiveClass)
4063 {
4064     m_primitiveUnitType = CSS_VALUE_ID;
4065     switch (isolation) {
4066     case IsolationAuto:
4067         m_value.valueID = CSSValueAuto;
4068         break;
4069     case IsolationIsolate:
4070         m_value.valueID = CSSValueIsolate;
4071         break;
4072     default:
4073         ASSERT_NOT_REACHED();
4074     }
4075 }
4076
4077 template<> inline CSSPrimitiveValue::operator Isolation() const
4078 {
4079     ASSERT(isValueID());
4080     switch (m_value.valueID) {
4081     case CSSValueAuto:
4082         return IsolationAuto;
4083     case CSSValueIsolate:
4084         return IsolationIsolate;
4085     default:
4086         break;
4087     }
4088
4089     ASSERT_NOT_REACHED();
4090     return IsolationAuto;
4091 }
4092
4093 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineCap e)
4094     : CSSValue(PrimitiveClass)
4095 {
4096     m_primitiveUnitType = CSS_VALUE_ID;
4097     switch (e) {
4098     case ButtCap:
4099         m_value.valueID = CSSValueButt;
4100         break;
4101     case RoundCap:
4102         m_value.valueID = CSSValueRound;
4103         break;
4104     case SquareCap:
4105         m_value.valueID = CSSValueSquare;
4106         break;
4107     }
4108 }
4109
4110 template<> inline CSSPrimitiveValue::operator LineCap() const
4111 {
4112     ASSERT(isValueID());
4113
4114     switch (m_value.valueID) {
4115     case CSSValueButt:
4116         return ButtCap;
4117     case CSSValueRound:
4118         return RoundCap;
4119     case CSSValueSquare:
4120         return SquareCap;
4121     default:
4122         break;
4123     }
4124
4125     ASSERT_NOT_REACHED();
4126     return ButtCap;
4127 }
4128
4129 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineJoin e)
4130     : CSSValue(PrimitiveClass)
4131 {
4132     m_primitiveUnitType = CSS_VALUE_ID;
4133     switch (e) {
4134     case MiterJoin:
4135         m_value.valueID = CSSValueMiter;
4136         break;
4137     case RoundJoin:
4138         m_value.valueID = CSSValueRound;
4139         break;
4140     case BevelJoin:
4141         m_value.valueID = CSSValueBevel;
4142         break;
4143     }
4144 }
4145
4146 template<> inline CSSPrimitiveValue::operator LineJoin() const
4147 {
4148     ASSERT(isValueID());
4149
4150     switch (m_value.valueID) {
4151     case CSSValueMiter:
4152         return MiterJoin;
4153     case CSSValueRound:
4154         return RoundJoin;
4155     case CSSValueBevel:
4156         return BevelJoin;
4157     default:
4158         break;
4159     }
4160
4161     ASSERT_NOT_REACHED();
4162     return MiterJoin;
4163 }
4164
4165 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(WindRule e)
4166     : CSSValue(PrimitiveClass)
4167 {
4168     m_primitiveUnitType = CSS_VALUE_ID;
4169     switch (e) {
4170     case RULE_NONZERO:
4171         m_value.valueID = CSSValueNonzero;
4172         break;
4173     case RULE_EVENODD:
4174         m_value.valueID = CSSValueEvenodd;
4175         break;
4176     }
4177 }
4178
4179 template<> inline CSSPrimitiveValue::operator WindRule() const
4180 {
4181     ASSERT(isValueID());
4182
4183     switch (m_value.valueID) {
4184     case CSSValueNonzero:
4185         return RULE_NONZERO;
4186     case CSSValueEvenodd:
4187         return RULE_EVENODD;
4188     default:
4189         break;
4190     }
4191
4192     ASSERT_NOT_REACHED();
4193     return RULE_NONZERO;
4194 }
4195
4196
4197 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EAlignmentBaseline e)
4198     : CSSValue(PrimitiveClass)
4199 {
4200     m_primitiveUnitType = CSS_VALUE_ID;
4201     switch (e) {
4202     case AB_AUTO:
4203         m_value.valueID = CSSValueAuto;
4204         break;
4205     case AB_BASELINE:
4206         m_value.valueID = CSSValueBaseline;
4207         break;
4208     case AB_BEFORE_EDGE:
4209         m_value.valueID = CSSValueBeforeEdge;
4210         break;
4211     case AB_TEXT_BEFORE_EDGE:
4212         m_value.valueID = CSSValueTextBeforeEdge;
4213         break;
4214     case AB_MIDDLE:
4215         m_value.valueID = CSSValueMiddle;
4216         break;
4217     case AB_CENTRAL:
4218         m_value.valueID = CSSValueCentral;
4219         break;
4220     case AB_AFTER_EDGE:
4221         m_value.valueID = CSSValueAfterEdge;
4222         break;
4223     case AB_TEXT_AFTER_EDGE:
4224         m_value.valueID = CSSValueTextAfterEdge;
4225         break;
4226     case AB_IDEOGRAPHIC:
4227         m_value.valueID = CSSValueIdeographic;
4228         break;
4229     case AB_ALPHABETIC:
4230         m_value.valueID = CSSValueAlphabetic;
4231         break;
4232     case AB_HANGING:
4233         m_value.valueID = CSSValueHanging;
4234         break;
4235     case AB_MATHEMATICAL:
4236         m_value.valueID = CSSValueMathematical;
4237         break;
4238     }
4239 }
4240
4241 template<> inline CSSPrimitiveValue::operator EAlignmentBaseline() const
4242 {
4243     ASSERT(isValueID());
4244
4245     switch (m_value.valueID) {
4246     case CSSValueAuto:
4247         return AB_AUTO;
4248     case CSSValueBaseline:
4249         return AB_BASELINE;
4250     case CSSValueBeforeEdge:
4251         return AB_BEFORE_EDGE;
4252     case CSSValueTextBeforeEdge:
4253