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