2d5e8ce6f48d858ccae2201571a13131c5e6fc69
[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         return TopToBottomWritingMode;
3246     case CSSValueVerticalRl:
3247         return RightToLeftWritingMode;
3248     case CSSValueVerticalLr:
3249         return LeftToRightWritingMode;
3250     case CSSValueHorizontalBt:
3251         return BottomToTopWritingMode;
3252     default:
3253         break;
3254     }
3255
3256     ASSERT_NOT_REACHED();
3257     return TopToBottomWritingMode;
3258 }
3259
3260 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextCombine e)
3261     : CSSValue(PrimitiveClass)
3262 {
3263     m_primitiveUnitType = CSS_VALUE_ID;
3264     switch (e) {
3265     case TextCombineNone:
3266         m_value.valueID = CSSValueNone;
3267         break;
3268     case TextCombineHorizontal:
3269         m_value.valueID = CSSValueHorizontal;
3270         break;
3271     }
3272 }
3273
3274 template<> inline CSSPrimitiveValue::operator TextCombine() const
3275 {
3276     ASSERT(isValueID());
3277
3278     switch (m_value.valueID) {
3279     case CSSValueNone:
3280         return TextCombineNone;
3281     case CSSValueHorizontal:
3282         return TextCombineHorizontal;
3283     default:
3284         break;
3285     }
3286
3287     ASSERT_NOT_REACHED();
3288     return TextCombineNone;
3289 }
3290
3291 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(RubyPosition position)
3292     : CSSValue(PrimitiveClass)
3293 {
3294     m_primitiveUnitType = CSS_VALUE_ID;
3295     switch (position) {
3296     case RubyPositionBefore:
3297         m_value.valueID = CSSValueBefore;
3298         break;
3299     case RubyPositionAfter:
3300         m_value.valueID = CSSValueAfter;
3301         break;
3302     case RubyPositionInterCharacter:
3303         m_value.valueID = CSSValueInterCharacter;
3304         break;
3305     }
3306 }
3307
3308 template<> inline CSSPrimitiveValue::operator RubyPosition() const
3309 {
3310     ASSERT(isValueID());
3311
3312     switch (m_value.valueID) {
3313     case CSSValueBefore:
3314         return RubyPositionBefore;
3315     case CSSValueAfter:
3316         return RubyPositionAfter;
3317     case CSSValueInterCharacter:
3318         return RubyPositionInterCharacter;
3319     default:
3320         break;
3321     }
3322
3323     ASSERT_NOT_REACHED();
3324     return RubyPositionBefore;
3325 }
3326
3327 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextOverflow overflow)
3328     : CSSValue(PrimitiveClass)
3329 {
3330     m_primitiveUnitType = CSS_VALUE_ID;
3331     switch (overflow) {
3332     case TextOverflowClip:
3333         m_value.valueID = CSSValueClip;
3334         break;
3335     case TextOverflowEllipsis:
3336         m_value.valueID = CSSValueEllipsis;
3337         break;
3338     }
3339 }
3340
3341 template<> inline CSSPrimitiveValue::operator TextOverflow() const
3342 {
3343     ASSERT(isValueID());
3344
3345     switch (m_value.valueID) {
3346     case CSSValueClip:
3347         return TextOverflowClip;
3348     case CSSValueEllipsis:
3349         return TextOverflowEllipsis;
3350     default:
3351         break;
3352     }
3353
3354     ASSERT_NOT_REACHED();
3355     return TextOverflowClip;
3356 }
3357
3358 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextEmphasisFill fill)
3359     : CSSValue(PrimitiveClass)
3360 {
3361     m_primitiveUnitType = CSS_VALUE_ID;
3362     switch (fill) {
3363     case TextEmphasisFillFilled:
3364         m_value.valueID = CSSValueFilled;
3365         break;
3366     case TextEmphasisFillOpen:
3367         m_value.valueID = CSSValueOpen;
3368         break;
3369     }
3370 }
3371
3372 template<> inline CSSPrimitiveValue::operator TextEmphasisFill() const
3373 {
3374     ASSERT(isValueID());
3375
3376     switch (m_value.valueID) {
3377     case CSSValueFilled:
3378         return TextEmphasisFillFilled;
3379     case CSSValueOpen:
3380         return TextEmphasisFillOpen;
3381     default:
3382         break;
3383     }
3384
3385     ASSERT_NOT_REACHED();
3386     return TextEmphasisFillFilled;
3387 }
3388
3389 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextEmphasisMark mark)
3390     : CSSValue(PrimitiveClass)
3391 {
3392     m_primitiveUnitType = CSS_VALUE_ID;
3393     switch (mark) {
3394     case TextEmphasisMarkDot:
3395         m_value.valueID = CSSValueDot;
3396         break;
3397     case TextEmphasisMarkCircle:
3398         m_value.valueID = CSSValueCircle;
3399         break;
3400     case TextEmphasisMarkDoubleCircle:
3401         m_value.valueID = CSSValueDoubleCircle;
3402         break;
3403     case TextEmphasisMarkTriangle:
3404         m_value.valueID = CSSValueTriangle;
3405         break;
3406     case TextEmphasisMarkSesame:
3407         m_value.valueID = CSSValueSesame;
3408         break;
3409     case TextEmphasisMarkNone:
3410     case TextEmphasisMarkAuto:
3411     case TextEmphasisMarkCustom:
3412         ASSERT_NOT_REACHED();
3413         m_value.valueID = CSSValueNone;
3414         break;
3415     }
3416 }
3417
3418 template<> inline CSSPrimitiveValue::operator TextEmphasisMark() const
3419 {
3420     ASSERT(isValueID());
3421
3422     switch (m_value.valueID) {
3423     case CSSValueNone:
3424         return TextEmphasisMarkNone;
3425     case CSSValueDot:
3426         return TextEmphasisMarkDot;
3427     case CSSValueCircle:
3428         return TextEmphasisMarkCircle;
3429     case CSSValueDoubleCircle:
3430         return TextEmphasisMarkDoubleCircle;
3431     case CSSValueTriangle:
3432         return TextEmphasisMarkTriangle;
3433     case CSSValueSesame:
3434         return TextEmphasisMarkSesame;
3435     default:
3436         break;
3437     }
3438
3439     ASSERT_NOT_REACHED();
3440     return TextEmphasisMarkNone;
3441 }
3442
3443 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextOrientation e)
3444     : CSSValue(PrimitiveClass)
3445 {
3446     m_primitiveUnitType = CSS_VALUE_ID;
3447     switch (e) {
3448     case TextOrientation::Sideways:
3449         m_value.valueID = CSSValueSideways;
3450         break;
3451     case TextOrientation::Mixed:
3452         m_value.valueID = CSSValueMixed;
3453         break;
3454     case TextOrientation::Upright:
3455         m_value.valueID = CSSValueUpright;
3456         break;
3457     }
3458 }
3459
3460 template<> inline CSSPrimitiveValue::operator TextOrientation() const
3461 {
3462     ASSERT(isValueID());
3463
3464     switch (m_value.valueID) {
3465     case CSSValueSideways:
3466         return TextOrientation::Sideways;
3467     case CSSValueSidewaysRight:
3468         return TextOrientation::Sideways;
3469     case CSSValueVerticalRight:
3470         return TextOrientation::Mixed;
3471     case CSSValueMixed:
3472         return TextOrientation::Mixed;
3473     case CSSValueUpright:
3474         return TextOrientation::Upright;
3475     default:
3476         break;
3477     }
3478
3479     ASSERT_NOT_REACHED();
3480     return TextOrientation::Mixed;
3481 }
3482
3483 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EPointerEvents e)
3484     : CSSValue(PrimitiveClass)
3485 {
3486     m_primitiveUnitType = CSS_VALUE_ID;
3487     switch (e) {
3488     case PE_NONE:
3489         m_value.valueID = CSSValueNone;
3490         break;
3491     case PE_STROKE:
3492         m_value.valueID = CSSValueStroke;
3493         break;
3494     case PE_FILL:
3495         m_value.valueID = CSSValueFill;
3496         break;
3497     case PE_PAINTED:
3498         m_value.valueID = CSSValuePainted;
3499         break;
3500     case PE_VISIBLE:
3501         m_value.valueID = CSSValueVisible;
3502         break;
3503     case PE_VISIBLE_STROKE:
3504         m_value.valueID = CSSValueVisiblestroke;
3505         break;
3506     case PE_VISIBLE_FILL:
3507         m_value.valueID = CSSValueVisiblefill;
3508         break;
3509     case PE_VISIBLE_PAINTED:
3510         m_value.valueID = CSSValueVisiblepainted;
3511         break;
3512     case PE_AUTO:
3513         m_value.valueID = CSSValueAuto;
3514         break;
3515     case PE_ALL:
3516         m_value.valueID = CSSValueAll;
3517         break;
3518     }
3519 }
3520
3521 template<> inline CSSPrimitiveValue::operator EPointerEvents() const
3522 {
3523     ASSERT(isValueID());
3524
3525     switch (m_value.valueID) {
3526     case CSSValueAll:
3527         return PE_ALL;
3528     case CSSValueAuto:
3529         return PE_AUTO;
3530     case CSSValueNone:
3531         return PE_NONE;
3532     case CSSValueVisiblepainted:
3533         return PE_VISIBLE_PAINTED;
3534     case CSSValueVisiblefill:
3535         return PE_VISIBLE_FILL;
3536     case CSSValueVisiblestroke:
3537         return PE_VISIBLE_STROKE;
3538     case CSSValueVisible:
3539         return PE_VISIBLE;
3540     case CSSValuePainted:
3541         return PE_PAINTED;
3542     case CSSValueFill:
3543         return PE_FILL;
3544     case CSSValueStroke:
3545         return PE_STROKE;
3546     default:
3547         break;
3548     }
3549
3550     ASSERT_NOT_REACHED();
3551     return PE_ALL;
3552 }
3553
3554 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(Kerning kerning)
3555     : CSSValue(PrimitiveClass)
3556 {
3557     m_primitiveUnitType = CSS_VALUE_ID;
3558     switch (kerning) {
3559     case Kerning::Auto:
3560         m_value.valueID = CSSValueAuto;
3561         return;
3562     case Kerning::Normal:
3563         m_value.valueID = CSSValueNormal;
3564         return;
3565     case Kerning::NoShift:
3566         m_value.valueID = CSSValueNone;
3567         return;
3568     }
3569
3570     ASSERT_NOT_REACHED();
3571     m_value.valueID = CSSValueAuto;
3572 }
3573
3574 template<> inline CSSPrimitiveValue::operator Kerning() const
3575 {
3576     ASSERT(isValueID());
3577
3578     switch (m_value.valueID) {
3579     case CSSValueAuto:
3580         return Kerning::Auto;
3581     case CSSValueNormal:
3582         return Kerning::Normal;
3583     case CSSValueNone:
3584         return Kerning::NoShift;
3585     default:
3586         break;
3587     }
3588
3589     ASSERT_NOT_REACHED();
3590     return Kerning::Auto;
3591 }
3592
3593 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ObjectFit fit)
3594     : CSSValue(PrimitiveClass)
3595 {
3596     m_primitiveUnitType = CSS_VALUE_ID;
3597     switch (fit) {
3598     case ObjectFitFill:
3599         m_value.valueID = CSSValueFill;
3600         break;
3601     case ObjectFitContain:
3602         m_value.valueID = CSSValueContain;
3603         break;
3604     case ObjectFitCover:
3605         m_value.valueID = CSSValueCover;
3606         break;
3607     case ObjectFitNone:
3608         m_value.valueID = CSSValueNone;
3609         break;
3610     case ObjectFitScaleDown:
3611         m_value.valueID = CSSValueScaleDown;
3612         break;
3613     }
3614 }
3615
3616 template<> inline CSSPrimitiveValue::operator ObjectFit() const
3617 {
3618     ASSERT(isValueID());
3619
3620     switch (m_value.valueID) {
3621     case CSSValueFill:
3622         return ObjectFitFill;
3623     case CSSValueContain:
3624         return ObjectFitContain;
3625     case CSSValueCover:
3626         return ObjectFitCover;
3627     case CSSValueNone:
3628         return ObjectFitNone;
3629     case CSSValueScaleDown:
3630         return ObjectFitScaleDown;
3631     default:
3632         ASSERT_NOT_REACHED();
3633         return ObjectFitFill;
3634     }
3635 }
3636
3637 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontSmoothingMode smoothing)
3638     : CSSValue(PrimitiveClass)
3639 {
3640     m_primitiveUnitType = CSS_VALUE_ID;
3641     switch (smoothing) {
3642     case AutoSmoothing:
3643         m_value.valueID = CSSValueAuto;
3644         return;
3645     case NoSmoothing:
3646         m_value.valueID = CSSValueNone;
3647         return;
3648     case Antialiased:
3649         m_value.valueID = CSSValueAntialiased;
3650         return;
3651     case SubpixelAntialiased:
3652         m_value.valueID = CSSValueSubpixelAntialiased;
3653         return;
3654     }
3655
3656     ASSERT_NOT_REACHED();
3657     m_value.valueID = CSSValueAuto;
3658 }
3659
3660 template<> inline CSSPrimitiveValue::operator FontSmoothingMode() const
3661 {
3662     ASSERT(isValueID());
3663
3664     switch (m_value.valueID) {
3665     case CSSValueAuto:
3666         return AutoSmoothing;
3667     case CSSValueNone:
3668         return NoSmoothing;
3669     case CSSValueAntialiased:
3670         return Antialiased;
3671     case CSSValueSubpixelAntialiased:
3672         return SubpixelAntialiased;
3673     default:
3674         break;
3675     }
3676
3677     ASSERT_NOT_REACHED();
3678     return AutoSmoothing;
3679 }
3680
3681 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontWeight weight)
3682     : CSSValue(PrimitiveClass)
3683 {
3684     m_primitiveUnitType = CSS_VALUE_ID;
3685     switch (weight) {
3686     case FontWeight900:
3687         m_value.valueID = CSSValue900;
3688         return;
3689     case FontWeight800:
3690         m_value.valueID = CSSValue800;
3691         return;
3692     case FontWeight700:
3693         m_value.valueID = CSSValue700;
3694         return;
3695     case FontWeight600:
3696         m_value.valueID = CSSValue600;
3697         return;
3698     case FontWeight500:
3699         m_value.valueID = CSSValue500;
3700         return;
3701     case FontWeight400:
3702         m_value.valueID = CSSValue400;
3703         return;
3704     case FontWeight300:
3705         m_value.valueID = CSSValue300;
3706         return;
3707     case FontWeight200:
3708         m_value.valueID = CSSValue200;
3709         return;
3710     case FontWeight100:
3711         m_value.valueID = CSSValue100;
3712         return;
3713     }
3714
3715     ASSERT_NOT_REACHED();
3716     m_value.valueID = CSSValueNormal;
3717 }
3718
3719 template<> inline CSSPrimitiveValue::operator FontWeight() const
3720 {
3721     ASSERT(isValueID());
3722
3723     switch (m_value.valueID) {
3724     case CSSValueBold:
3725         return FontWeightBold;
3726     case CSSValueNormal:
3727         return FontWeightNormal;
3728     case CSSValue900:
3729         return FontWeight900;
3730     case CSSValue800:
3731         return FontWeight800;
3732     case CSSValue700:
3733         return FontWeight700;
3734     case CSSValue600:
3735         return FontWeight600;
3736     case CSSValue500:
3737         return FontWeight500;
3738     case CSSValue400:
3739         return FontWeight400;
3740     case CSSValue300:
3741         return FontWeight300;
3742     case CSSValue200:
3743         return FontWeight200;
3744     case CSSValue100:
3745         return FontWeight100;
3746     default:
3747         break;
3748     }
3749
3750     ASSERT_NOT_REACHED();
3751     return FontWeightNormal;
3752 }
3753
3754 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontItalic italic)
3755     : CSSValue(PrimitiveClass)
3756 {
3757     m_primitiveUnitType = CSS_VALUE_ID;
3758     switch (italic) {
3759     case FontItalicOff:
3760         m_value.valueID = CSSValueNormal;
3761         return;
3762     case FontItalicOn:
3763         m_value.valueID = CSSValueItalic;
3764         return;
3765     }
3766
3767     ASSERT_NOT_REACHED();
3768     m_value.valueID = CSSValueNormal;
3769 }
3770
3771 template<> inline CSSPrimitiveValue::operator FontItalic() const
3772 {
3773     ASSERT(isValueID());
3774
3775     switch (m_value.valueID) {
3776     case CSSValueOblique:
3777     // FIXME: oblique is the same as italic for the moment...
3778     case CSSValueItalic:
3779         return FontItalicOn;
3780     case CSSValueNormal:
3781         return FontItalicOff;
3782     default:
3783         break;
3784     }
3785     ASSERT_NOT_REACHED();
3786     return FontItalicOff;
3787 }
3788
3789 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontSmallCaps smallCaps)
3790     : CSSValue(PrimitiveClass)
3791 {
3792     m_primitiveUnitType = CSS_VALUE_ID;
3793     switch (smallCaps) {
3794     case FontSmallCapsOff:
3795         m_value.valueID = CSSValueNormal;
3796         return;
3797     case FontSmallCapsOn:
3798         m_value.valueID = CSSValueSmallCaps;
3799         return;
3800     }
3801
3802     ASSERT_NOT_REACHED();
3803     m_value.valueID = CSSValueNormal;
3804 }
3805
3806 template<> inline CSSPrimitiveValue::operator FontSmallCaps() const
3807 {
3808     ASSERT(isValueID());
3809
3810     switch (m_value.valueID) {
3811     case CSSValueSmallCaps:
3812         return FontSmallCapsOn;
3813     case CSSValueNormal:
3814         return FontSmallCapsOff;
3815     default:
3816         break;
3817     }
3818     ASSERT_NOT_REACHED();
3819     return FontSmallCapsOff;
3820 }
3821
3822 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextRenderingMode e)
3823     : CSSValue(PrimitiveClass)
3824 {
3825     m_primitiveUnitType = CSS_VALUE_ID;
3826     switch (e) {
3827     case AutoTextRendering:
3828         m_value.valueID = CSSValueAuto;
3829         break;
3830     case OptimizeSpeed:
3831         m_value.valueID = CSSValueOptimizespeed;
3832         break;
3833     case OptimizeLegibility:
3834         m_value.valueID = CSSValueOptimizelegibility;
3835         break;
3836     case GeometricPrecision:
3837         m_value.valueID = CSSValueGeometricprecision;
3838         break;
3839     }
3840 }
3841
3842 template<> inline CSSPrimitiveValue::operator TextRenderingMode() const
3843 {
3844     ASSERT(isValueID());
3845
3846     switch (m_value.valueID) {
3847     case CSSValueAuto:
3848         return AutoTextRendering;
3849     case CSSValueOptimizespeed:
3850         return OptimizeSpeed;
3851     case CSSValueOptimizelegibility:
3852         return OptimizeLegibility;
3853     case CSSValueGeometricprecision:
3854         return GeometricPrecision;
3855     default:
3856         break;
3857     }
3858
3859     ASSERT_NOT_REACHED();
3860     return AutoTextRendering;
3861 }
3862
3863 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(Hyphens hyphens)
3864     : CSSValue(PrimitiveClass)
3865 {
3866     m_primitiveUnitType = CSS_VALUE_ID;
3867     switch (hyphens) {
3868     case HyphensNone:
3869         m_value.valueID = CSSValueNone;
3870         break;
3871     case HyphensManual:
3872         m_value.valueID = CSSValueManual;
3873         break;
3874     case HyphensAuto:
3875         m_value.valueID = CSSValueAuto;
3876         break;
3877     }
3878 }
3879
3880 template<> inline CSSPrimitiveValue::operator Hyphens() const
3881 {
3882     ASSERT(isValueID());
3883
3884     switch (m_value.valueID) {
3885     case CSSValueNone:
3886         return HyphensNone;
3887     case CSSValueManual:
3888         return HyphensManual;
3889     case CSSValueAuto:
3890         return HyphensAuto;
3891     default:
3892         break;
3893     }
3894
3895     ASSERT_NOT_REACHED();
3896     return HyphensAuto;
3897 }
3898
3899 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineSnap gridSnap)
3900     : CSSValue(PrimitiveClass)
3901 {
3902     m_primitiveUnitType = CSS_VALUE_ID;
3903     switch (gridSnap) {
3904     case LineSnapNone:
3905         m_value.valueID = CSSValueNone;
3906         break;
3907     case LineSnapBaseline:
3908         m_value.valueID = CSSValueBaseline;
3909         break;
3910     case LineSnapContain:
3911         m_value.valueID = CSSValueContain;
3912         break;
3913     }
3914 }
3915
3916 template<> inline CSSPrimitiveValue::operator LineSnap() const
3917 {
3918     ASSERT(isValueID());
3919
3920     switch (m_value.valueID) {
3921     case CSSValueNone:
3922         return LineSnapNone;
3923     case CSSValueBaseline:
3924         return LineSnapBaseline;
3925     case CSSValueContain:
3926         return LineSnapContain;
3927     default:
3928         break;
3929     }
3930
3931     ASSERT_NOT_REACHED();
3932     return LineSnapNone;
3933 }
3934
3935 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineAlign lineAlign)
3936     : CSSValue(PrimitiveClass)
3937 {
3938     m_primitiveUnitType = CSS_VALUE_ID;
3939     switch (lineAlign) {
3940     case LineAlignNone:
3941         m_value.valueID = CSSValueNone;
3942         break;
3943     case LineAlignEdges:
3944         m_value.valueID = CSSValueEdges;
3945         break;
3946     }
3947 }
3948
3949 template<> inline CSSPrimitiveValue::operator LineAlign() const
3950 {
3951     ASSERT(isValueID());
3952
3953     switch (m_value.valueID) {
3954     case CSSValueNone:
3955         return LineAlignNone;
3956     case CSSValueEdges:
3957         return LineAlignEdges;
3958     default:
3959         break;
3960     }
3961
3962     ASSERT_NOT_REACHED();
3963     return LineAlignNone;
3964 }
3965
3966 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ESpeak e)
3967     : CSSValue(PrimitiveClass)
3968 {
3969     m_primitiveUnitType = CSS_VALUE_ID;
3970     switch (e) {
3971     case SpeakNone:
3972         m_value.valueID = CSSValueNone;
3973         break;
3974     case SpeakNormal:
3975         m_value.valueID = CSSValueNormal;
3976         break;
3977     case SpeakSpellOut:
3978         m_value.valueID = CSSValueSpellOut;
3979         break;
3980     case SpeakDigits:
3981         m_value.valueID = CSSValueDigits;
3982         break;
3983     case SpeakLiteralPunctuation:
3984         m_value.valueID = CSSValueLiteralPunctuation;
3985         break;
3986     case SpeakNoPunctuation:
3987         m_value.valueID = CSSValueNoPunctuation;
3988         break;
3989     }
3990 }
3991
3992 template<> inline CSSPrimitiveValue::operator Order() const
3993 {
3994     ASSERT(isValueID());
3995
3996     switch (m_value.valueID) {
3997     case CSSValueLogical:
3998         return LogicalOrder;
3999     case CSSValueVisual:
4000         return VisualOrder;
4001     default:
4002         break;
4003     }
4004
4005     ASSERT_NOT_REACHED();
4006     return LogicalOrder;
4007 }
4008
4009 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(Order e)
4010     : CSSValue(PrimitiveClass)
4011 {
4012     m_primitiveUnitType = CSS_VALUE_ID;
4013     switch (e) {
4014     case LogicalOrder:
4015         m_value.valueID = CSSValueLogical;
4016         break;
4017     case VisualOrder:
4018         m_value.valueID = CSSValueVisual;
4019         break;
4020     }
4021 }
4022
4023 template<> inline CSSPrimitiveValue::operator ESpeak() const
4024 {
4025     ASSERT(isValueID());
4026
4027     switch (m_value.valueID) {
4028     case CSSValueNone:
4029         return SpeakNone;
4030     case CSSValueNormal:
4031         return SpeakNormal;
4032     case CSSValueSpellOut:
4033         return SpeakSpellOut;
4034     case CSSValueDigits:
4035         return SpeakDigits;
4036     case CSSValueLiteralPunctuation:
4037         return SpeakLiteralPunctuation;
4038     case CSSValueNoPunctuation:
4039         return SpeakNoPunctuation;
4040     default:
4041         break;
4042     }
4043
4044     ASSERT_NOT_REACHED();
4045     return SpeakNormal;
4046 }
4047
4048 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(BlendMode blendMode)
4049     : CSSValue(PrimitiveClass)
4050 {
4051     m_primitiveUnitType = CSS_VALUE_ID;
4052     switch (blendMode) {
4053     case BlendModeNormal:
4054         m_value.valueID = CSSValueNormal;
4055         break;
4056     case BlendModeMultiply:
4057         m_value.valueID = CSSValueMultiply;
4058         break;
4059     case BlendModeScreen:
4060         m_value.valueID = CSSValueScreen;
4061         break;
4062     case BlendModeOverlay:
4063         m_value.valueID = CSSValueOverlay;
4064         break;
4065     case BlendModeDarken:
4066         m_value.valueID = CSSValueDarken;
4067         break;
4068     case BlendModeLighten:
4069         m_value.valueID = CSSValueLighten;
4070         break;
4071     case BlendModeColorDodge:
4072         m_value.valueID = CSSValueColorDodge;
4073         break;
4074     case BlendModeColorBurn:
4075         m_value.valueID = CSSValueColorBurn;
4076         break;
4077     case BlendModeHardLight:
4078         m_value.valueID = CSSValueHardLight;
4079         break;
4080     case BlendModeSoftLight:
4081         m_value.valueID = CSSValueSoftLight;
4082         break;
4083     case BlendModeDifference:
4084         m_value.valueID = CSSValueDifference;
4085         break;
4086     case BlendModeExclusion:
4087         m_value.valueID = CSSValueExclusion;
4088         break;
4089     case BlendModeHue:
4090         m_value.valueID = CSSValueHue;
4091         break;
4092     case BlendModeSaturation:
4093         m_value.valueID = CSSValueSaturation;
4094         break;
4095     case BlendModeColor:
4096         m_value.valueID = CSSValueColor;
4097         break;
4098     case BlendModeLuminosity:
4099         m_value.valueID = CSSValueLuminosity;
4100         break;
4101     case BlendModePlusDarker:
4102         m_value.valueID = CSSValuePlusDarker;
4103         break;
4104     case BlendModePlusLighter:
4105         m_value.valueID = CSSValuePlusLighter;
4106         break;
4107     }
4108 }
4109
4110 template<> inline CSSPrimitiveValue::operator BlendMode() const
4111 {
4112     ASSERT(isValueID());
4113
4114     switch (m_value.valueID) {
4115     case CSSValueNormal:
4116         return BlendModeNormal;
4117     case CSSValueMultiply:
4118         return BlendModeMultiply;
4119     case CSSValueScreen:
4120         return BlendModeScreen;
4121     case CSSValueOverlay:
4122         return BlendModeOverlay;
4123     case CSSValueDarken:
4124         return BlendModeDarken;
4125     case CSSValueLighten:
4126         return BlendModeLighten;
4127     case CSSValueColorDodge:
4128         return BlendModeColorDodge;
4129     case CSSValueColorBurn:
4130         return BlendModeColorBurn;
4131     case CSSValueHardLight:
4132         return BlendModeHardLight;
4133     case CSSValueSoftLight:
4134         return BlendModeSoftLight;
4135     case CSSValueDifference:
4136         return BlendModeDifference;
4137     case CSSValueExclusion:
4138         return BlendModeExclusion;
4139     case CSSValueHue:
4140         return BlendModeHue;
4141     case CSSValueSaturation:
4142         return BlendModeSaturation;
4143     case CSSValueColor:
4144         return BlendModeColor;
4145     case CSSValueLuminosity:
4146         return BlendModeLuminosity;
4147     case CSSValuePlusDarker:
4148         return BlendModePlusDarker;
4149     case CSSValuePlusLighter:
4150         return BlendModePlusLighter;
4151     default:
4152         break;
4153     }
4154
4155     ASSERT_NOT_REACHED();
4156     return BlendModeNormal;
4157 }
4158
4159 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(Isolation isolation)
4160     : CSSValue(PrimitiveClass)
4161 {
4162     m_primitiveUnitType = CSS_VALUE_ID;
4163     switch (isolation) {
4164     case IsolationAuto:
4165         m_value.valueID = CSSValueAuto;
4166         break;
4167     case IsolationIsolate:
4168         m_value.valueID = CSSValueIsolate;
4169         break;
4170     default:
4171         ASSERT_NOT_REACHED();
4172     }
4173 }
4174
4175 template<> inline CSSPrimitiveValue::operator Isolation() const
4176 {
4177     ASSERT(isValueID());
4178     switch (m_value.valueID) {
4179     case CSSValueAuto:
4180         return IsolationAuto;
4181     case CSSValueIsolate:
4182         return IsolationIsolate;
4183     default:
4184         break;
4185     }
4186
4187     ASSERT_NOT_REACHED();
4188     return IsolationAuto;
4189 }
4190
4191 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineCap e)
4192     : CSSValue(PrimitiveClass)
4193 {
4194     m_primitiveUnitType = CSS_VALUE_ID;
4195     switch (e) {
4196     case ButtCap:
4197         m_value.valueID = CSSValueButt;
4198         break;
4199     case RoundCap:
4200         m_value.valueID = CSSValueRound;
4201         break;
4202     case SquareCap:
4203         m_value.valueID = CSSValueSquare;
4204         break;
4205     }
4206 }
4207
4208 template<> inline CSSPrimitiveValue::operator LineCap() const
4209 {
4210     ASSERT(isValueID());
4211
4212     switch (m_value.valueID) {
4213     case CSSValueButt:
4214         return ButtCap;
4215     case CSSValueRound:
4216         return RoundCap;
4217     case CSSValueSquare:
4218         return SquareCap;
4219     default:
4220         break;
4221     }
4222
4223     ASSERT_NOT_REACHED();
4224     return ButtCap;
4225 }
4226
4227 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineJoin e)
4228     : CSSValue(PrimitiveClass)
4229 {
4230     m_primitiveUnitType = CSS_VALUE_ID;
4231     switch (e) {
4232     case MiterJoin:
4233         m_value.valueID = CSSValueMiter;
4234         break;
4235     case RoundJoin:
4236         m_value.valueID = CSSValueRound;
4237         break;
4238     case BevelJoin:
4239         m_value.valueID = CSSValueBevel;
4240         break;
4241     }
4242 }
4243
4244 template<> inline CSSPrimitiveValue::operator LineJoin() const
4245 {
4246     ASSERT(isValueID());
4247
4248     switch (m_value.valueID) {
4249     case CSSValueMiter:
4250         return MiterJoin;
4251     case CSSValueRound:
4252         return RoundJoin;
4253     case CSSValueBevel: