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