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