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