Repeated background images have the wrong position when using bottom/right-relative...
[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     }
1392 }
1393
1394 template<> inline CSSPrimitiveValue::operator EDisplay() const
1395 {
1396     ASSERT(isValueID());
1397
1398     if (m_value.valueID == CSSValueNone)
1399         return NONE;
1400
1401     EDisplay display = static_cast<EDisplay>(m_value.valueID - CSSValueInline);
1402     ASSERT(display >= INLINE && display <= NONE);
1403     if (display == WEBKIT_FLEX)
1404         return FLEX;
1405     if (display == WEBKIT_INLINE_FLEX)
1406         return INLINE_FLEX;
1407     return display;
1408 }
1409
1410 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EEmptyCell e)
1411     : CSSValue(PrimitiveClass)
1412 {
1413     m_primitiveUnitType = CSS_VALUE_ID;
1414     switch (e) {
1415     case SHOW:
1416         m_value.valueID = CSSValueShow;
1417         break;
1418     case HIDE:
1419         m_value.valueID = CSSValueHide;
1420         break;
1421     }
1422 }
1423
1424 template<> inline CSSPrimitiveValue::operator EEmptyCell() const
1425 {
1426     ASSERT(isValueID());
1427
1428     switch (m_value.valueID) {
1429     case CSSValueShow:
1430         return SHOW;
1431     case CSSValueHide:
1432         return HIDE;
1433     default:
1434         break;
1435     }
1436
1437     ASSERT_NOT_REACHED();
1438     return SHOW;
1439 }
1440
1441 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFlexDirection e)
1442     : CSSValue(PrimitiveClass)
1443 {
1444     m_primitiveUnitType = CSS_VALUE_ID;
1445     switch (e) {
1446     case FlowRow:
1447         m_value.valueID = CSSValueRow;
1448         break;
1449     case FlowRowReverse:
1450         m_value.valueID = CSSValueRowReverse;
1451         break;
1452     case FlowColumn:
1453         m_value.valueID = CSSValueColumn;
1454         break;
1455     case FlowColumnReverse:
1456         m_value.valueID = CSSValueColumnReverse;
1457         break;
1458     }
1459 }
1460
1461 template<> inline CSSPrimitiveValue::operator EFlexDirection() const
1462 {
1463     ASSERT(isValueID());
1464
1465     switch (m_value.valueID) {
1466     case CSSValueRow:
1467         return FlowRow;
1468     case CSSValueRowReverse:
1469         return FlowRowReverse;
1470     case CSSValueColumn:
1471         return FlowColumn;
1472     case CSSValueColumnReverse:
1473         return FlowColumnReverse;
1474     default:
1475         break;
1476     }
1477
1478     ASSERT_NOT_REACHED();
1479     return FlowRow;
1480 }
1481
1482 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EAlignContent e)
1483     : CSSValue(PrimitiveClass)
1484 {
1485     m_primitiveUnitType = CSS_VALUE_ID;
1486     switch (e) {
1487     case AlignContentFlexStart:
1488         m_value.valueID = CSSValueFlexStart;
1489         break;
1490     case AlignContentFlexEnd:
1491         m_value.valueID = CSSValueFlexEnd;
1492         break;
1493     case AlignContentCenter:
1494         m_value.valueID = CSSValueCenter;
1495         break;
1496     case AlignContentSpaceBetween:
1497         m_value.valueID = CSSValueSpaceBetween;
1498         break;
1499     case AlignContentSpaceAround:
1500         m_value.valueID = CSSValueSpaceAround;
1501         break;
1502     case AlignContentStretch:
1503         m_value.valueID = CSSValueStretch;
1504         break;
1505     }
1506 }
1507
1508 template<> inline CSSPrimitiveValue::operator EAlignContent() const
1509 {
1510     ASSERT(isValueID());
1511
1512     switch (m_value.valueID) {
1513     case CSSValueFlexStart:
1514         return AlignContentFlexStart;
1515     case CSSValueFlexEnd:
1516         return AlignContentFlexEnd;
1517     case CSSValueCenter:
1518         return AlignContentCenter;
1519     case CSSValueSpaceBetween:
1520         return AlignContentSpaceBetween;
1521     case CSSValueSpaceAround:
1522         return AlignContentSpaceAround;
1523     case CSSValueStretch:
1524         return AlignContentStretch;
1525     default:
1526         break;
1527     }
1528
1529     ASSERT_NOT_REACHED();
1530     return AlignContentStretch;
1531 }
1532
1533 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFlexWrap e)
1534     : CSSValue(PrimitiveClass)
1535 {
1536     m_primitiveUnitType = CSS_VALUE_ID;
1537     switch (e) {
1538     case FlexNoWrap:
1539         m_value.valueID = CSSValueNowrap;
1540         break;
1541     case FlexWrap:
1542         m_value.valueID = CSSValueWrap;
1543         break;
1544     case FlexWrapReverse:
1545         m_value.valueID = CSSValueWrapReverse;
1546         break;
1547     }
1548 }
1549
1550 template<> inline CSSPrimitiveValue::operator EFlexWrap() const
1551 {
1552     ASSERT(isValueID());
1553
1554     switch (m_value.valueID) {
1555     case CSSValueNowrap:
1556         return FlexNoWrap;
1557     case CSSValueWrap:
1558         return FlexWrap;
1559     case CSSValueWrapReverse:
1560         return FlexWrapReverse;
1561     default:
1562         break;
1563     }
1564
1565     ASSERT_NOT_REACHED();
1566     return FlexNoWrap;
1567 }
1568
1569 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFloat e)
1570     : CSSValue(PrimitiveClass)
1571 {
1572     m_primitiveUnitType = CSS_VALUE_ID;
1573     switch (e) {
1574     case NoFloat:
1575         m_value.valueID = CSSValueNone;
1576         break;
1577     case LeftFloat:
1578         m_value.valueID = CSSValueLeft;
1579         break;
1580     case RightFloat:
1581         m_value.valueID = CSSValueRight;
1582         break;
1583     }
1584 }
1585
1586 template<> inline CSSPrimitiveValue::operator EFloat() const
1587 {
1588     ASSERT(isValueID());
1589
1590     switch (m_value.valueID) {
1591     case CSSValueLeft:
1592         return LeftFloat;
1593     case CSSValueRight:
1594         return RightFloat;
1595     case CSSValueNone:
1596     case CSSValueCenter: // Non-standard CSS value.
1597         return NoFloat;
1598     default:
1599         break;
1600     }
1601
1602     ASSERT_NOT_REACHED();
1603     return NoFloat;
1604 }
1605
1606 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineBreak e)
1607     : CSSValue(PrimitiveClass)
1608 {
1609     m_primitiveUnitType = CSS_VALUE_ID;
1610     switch (e) {
1611     case LineBreakAuto:
1612         m_value.valueID = CSSValueAuto;
1613         break;
1614     case LineBreakLoose:
1615         m_value.valueID = CSSValueLoose;
1616         break;
1617     case LineBreakNormal:
1618         m_value.valueID = CSSValueNormal;
1619         break;
1620     case LineBreakStrict:
1621         m_value.valueID = CSSValueStrict;
1622         break;
1623     case LineBreakAfterWhiteSpace:
1624         m_value.valueID = CSSValueAfterWhiteSpace;
1625         break;
1626     }
1627 }
1628
1629 template<> inline CSSPrimitiveValue::operator HangingPunctuation() const
1630 {
1631     ASSERT(isValueID());
1632     
1633     switch (m_value.valueID) {
1634     case CSSValueNone:
1635         return NoHangingPunctuation;
1636     case CSSValueFirst:
1637         return FirstHangingPunctuation;
1638     case CSSValueLast:
1639         return LastHangingPunctuation;
1640     case CSSValueAllowEnd:
1641         return AllowEndHangingPunctuation;
1642     case CSSValueForceEnd:
1643         return ForceEndHangingPunctuation;
1644     default:
1645         break;
1646     }
1647     
1648     ASSERT_NOT_REACHED();
1649     return NoHangingPunctuation;
1650 }
1651
1652 template<> inline CSSPrimitiveValue::operator LineBreak() const
1653 {
1654     ASSERT(isValueID());
1655
1656     switch (m_value.valueID) {
1657     case CSSValueAuto:
1658         return LineBreakAuto;
1659     case CSSValueLoose:
1660         return LineBreakLoose;
1661     case CSSValueNormal:
1662         return LineBreakNormal;
1663     case CSSValueStrict:
1664         return LineBreakStrict;
1665     case CSSValueAfterWhiteSpace:
1666         return LineBreakAfterWhiteSpace;
1667     default:
1668         break;
1669     }
1670
1671     ASSERT_NOT_REACHED();
1672     return LineBreakAuto;
1673 }
1674
1675 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EListStylePosition e)
1676     : CSSValue(PrimitiveClass)
1677 {
1678     m_primitiveUnitType = CSS_VALUE_ID;
1679     switch (e) {
1680     case OUTSIDE:
1681         m_value.valueID = CSSValueOutside;
1682         break;
1683     case INSIDE:
1684         m_value.valueID = CSSValueInside;
1685         break;
1686     }
1687 }
1688
1689 template<> inline CSSPrimitiveValue::operator EListStylePosition() const
1690 {
1691     ASSERT(isValueID());
1692
1693     switch (m_value.valueID) {
1694     case CSSValueOutside:
1695         return OUTSIDE;
1696     case CSSValueInside:
1697         return INSIDE;
1698     default:
1699         break;
1700     }
1701
1702     ASSERT_NOT_REACHED();
1703     return OUTSIDE;
1704 }
1705
1706 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EListStyleType e)
1707     : CSSValue(PrimitiveClass)
1708 {
1709     m_primitiveUnitType = CSS_VALUE_ID;
1710     switch (e) {
1711     case Afar:
1712         m_value.valueID = CSSValueAfar;
1713         break;
1714     case Amharic:
1715         m_value.valueID = CSSValueAmharic;
1716         break;
1717     case AmharicAbegede:
1718         m_value.valueID = CSSValueAmharicAbegede;
1719         break;
1720     case ArabicIndic:
1721         m_value.valueID = CSSValueArabicIndic;
1722         break;
1723     case Armenian:
1724         m_value.valueID = CSSValueArmenian;
1725         break;
1726     case Asterisks:
1727         m_value.valueID = CSSValueAsterisks;
1728         break;
1729     case BinaryListStyle:
1730         m_value.valueID = CSSValueBinary;
1731         break;
1732     case Bengali:
1733         m_value.valueID = CSSValueBengali;
1734         break;
1735     case Cambodian:
1736         m_value.valueID = CSSValueCambodian;
1737         break;
1738     case Circle:
1739         m_value.valueID = CSSValueCircle;
1740         break;
1741     case CjkEarthlyBranch:
1742         m_value.valueID = CSSValueCjkEarthlyBranch;
1743         break;
1744     case CjkHeavenlyStem:
1745         m_value.valueID = CSSValueCjkHeavenlyStem;
1746         break;
1747     case CJKIdeographic:
1748         m_value.valueID = CSSValueCjkIdeographic;
1749         break;
1750     case DecimalLeadingZero:
1751         m_value.valueID = CSSValueDecimalLeadingZero;
1752         break;
1753     case DecimalListStyle:
1754         m_value.valueID = CSSValueDecimal;
1755         break;
1756     case Devanagari:
1757         m_value.valueID = CSSValueDevanagari;
1758         break;
1759     case Disc:
1760         m_value.valueID = CSSValueDisc;
1761         break;
1762     case Ethiopic:
1763         m_value.valueID = CSSValueEthiopic;
1764         break;
1765     case EthiopicAbegede:
1766         m_value.valueID = CSSValueEthiopicAbegede;
1767         break;
1768     case EthiopicAbegedeAmEt:
1769         m_value.valueID = CSSValueEthiopicAbegedeAmEt;
1770         break;
1771     case EthiopicAbegedeGez:
1772         m_value.valueID = CSSValueEthiopicAbegedeGez;
1773         break;
1774     case EthiopicAbegedeTiEr:
1775         m_value.valueID = CSSValueEthiopicAbegedeTiEr;
1776         break;
1777     case EthiopicAbegedeTiEt:
1778         m_value.valueID = CSSValueEthiopicAbegedeTiEt;
1779         break;
1780     case EthiopicHalehameAaEr:
1781         m_value.valueID = CSSValueEthiopicHalehameAaEr;
1782         break;
1783     case EthiopicHalehameAaEt:
1784         m_value.valueID = CSSValueEthiopicHalehameAaEt;
1785         break;
1786     case EthiopicHalehameAmEt:
1787         m_value.valueID = CSSValueEthiopicHalehameAmEt;
1788         break;
1789     case EthiopicHalehameGez:
1790         m_value.valueID = CSSValueEthiopicHalehameGez;
1791         break;
1792     case EthiopicHalehameOmEt:
1793         m_value.valueID = CSSValueEthiopicHalehameOmEt;
1794         break;
1795     case EthiopicHalehameSidEt:
1796         m_value.valueID = CSSValueEthiopicHalehameSidEt;
1797         break;
1798     case EthiopicHalehameSoEt:
1799         m_value.valueID = CSSValueEthiopicHalehameSoEt;
1800         break;
1801     case EthiopicHalehameTiEr:
1802         m_value.valueID = CSSValueEthiopicHalehameTiEr;
1803         break;
1804     case EthiopicHalehameTiEt:
1805         m_value.valueID = CSSValueEthiopicHalehameTiEt;
1806         break;
1807     case EthiopicHalehameTig:
1808         m_value.valueID = CSSValueEthiopicHalehameTig;
1809         break;
1810     case Footnotes:
1811         m_value.valueID = CSSValueFootnotes;
1812         break;
1813     case Georgian:
1814         m_value.valueID = CSSValueGeorgian;
1815         break;
1816     case Gujarati:
1817         m_value.valueID = CSSValueGujarati;
1818         break;
1819     case Gurmukhi:
1820         m_value.valueID = CSSValueGurmukhi;
1821         break;
1822     case Hangul:
1823         m_value.valueID = CSSValueHangul;
1824         break;
1825     case HangulConsonant:
1826         m_value.valueID = CSSValueHangulConsonant;
1827         break;
1828     case Hebrew:
1829         m_value.valueID = CSSValueHebrew;
1830         break;
1831     case Hiragana:
1832         m_value.valueID = CSSValueHiragana;
1833         break;
1834     case HiraganaIroha:
1835         m_value.valueID = CSSValueHiraganaIroha;
1836         break;
1837     case Kannada:
1838         m_value.valueID = CSSValueKannada;
1839         break;
1840     case Katakana:
1841         m_value.valueID = CSSValueKatakana;
1842         break;
1843     case KatakanaIroha:
1844         m_value.valueID = CSSValueKatakanaIroha;
1845         break;
1846     case Khmer:
1847         m_value.valueID = CSSValueKhmer;
1848         break;
1849     case Lao:
1850         m_value.valueID = CSSValueLao;
1851         break;
1852     case LowerAlpha:
1853         m_value.valueID = CSSValueLowerAlpha;
1854         break;
1855     case LowerArmenian:
1856         m_value.valueID = CSSValueLowerArmenian;
1857         break;
1858     case LowerGreek:
1859         m_value.valueID = CSSValueLowerGreek;
1860         break;
1861     case LowerHexadecimal:
1862         m_value.valueID = CSSValueLowerHexadecimal;
1863         break;
1864     case LowerLatin:
1865         m_value.valueID = CSSValueLowerLatin;
1866         break;
1867     case LowerNorwegian:
1868         m_value.valueID = CSSValueLowerNorwegian;
1869         break;
1870     case LowerRoman:
1871         m_value.valueID = CSSValueLowerRoman;
1872         break;
1873     case Malayalam:
1874         m_value.valueID = CSSValueMalayalam;
1875         break;
1876     case Mongolian:
1877         m_value.valueID = CSSValueMongolian;
1878         break;
1879     case Myanmar:
1880         m_value.valueID = CSSValueMyanmar;
1881         break;
1882     case NoneListStyle:
1883         m_value.valueID = CSSValueNone;
1884         break;
1885     case Octal:
1886         m_value.valueID = CSSValueOctal;
1887         break;
1888     case Oriya:
1889         m_value.valueID = CSSValueOriya;
1890         break;
1891     case Oromo:
1892         m_value.valueID = CSSValueOromo;
1893         break;
1894     case Persian:
1895         m_value.valueID = CSSValuePersian;
1896         break;
1897     case Sidama:
1898         m_value.valueID = CSSValueSidama;
1899         break;
1900     case Somali:
1901         m_value.valueID = CSSValueSomali;
1902         break;
1903     case Square:
1904         m_value.valueID = CSSValueSquare;
1905         break;
1906     case Telugu:
1907         m_value.valueID = CSSValueTelugu;
1908         break;
1909     case Thai:
1910         m_value.valueID = CSSValueThai;
1911         break;
1912     case Tibetan:
1913         m_value.valueID = CSSValueTibetan;
1914         break;
1915     case Tigre:
1916         m_value.valueID = CSSValueTigre;
1917         break;
1918     case TigrinyaEr:
1919         m_value.valueID = CSSValueTigrinyaEr;
1920         break;
1921     case TigrinyaErAbegede:
1922         m_value.valueID = CSSValueTigrinyaErAbegede;
1923         break;
1924     case TigrinyaEt:
1925         m_value.valueID = CSSValueTigrinyaEt;
1926         break;
1927     case TigrinyaEtAbegede:
1928         m_value.valueID = CSSValueTigrinyaEtAbegede;
1929         break;
1930     case UpperAlpha:
1931         m_value.valueID = CSSValueUpperAlpha;
1932         break;
1933     case UpperArmenian:
1934         m_value.valueID = CSSValueUpperArmenian;
1935         break;
1936     case UpperGreek:
1937         m_value.valueID = CSSValueUpperGreek;
1938         break;
1939     case UpperHexadecimal:
1940         m_value.valueID = CSSValueUpperHexadecimal;
1941         break;
1942     case UpperLatin:
1943         m_value.valueID = CSSValueUpperLatin;
1944         break;
1945     case UpperNorwegian:
1946         m_value.valueID = CSSValueUpperNorwegian;
1947         break;
1948     case UpperRoman:
1949         m_value.valueID = CSSValueUpperRoman;
1950         break;
1951     case Urdu:
1952         m_value.valueID = CSSValueUrdu;
1953         break;
1954     }
1955 }
1956
1957 template<> inline CSSPrimitiveValue::operator EListStyleType() const
1958 {
1959     ASSERT(isValueID());
1960
1961     switch (m_value.valueID) {
1962     case CSSValueNone:
1963         return NoneListStyle;
1964     default:
1965         return static_cast<EListStyleType>(m_value.valueID - CSSValueDisc);
1966     }
1967 }
1968
1969 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EMarginCollapse e)
1970     : CSSValue(PrimitiveClass)
1971 {
1972     m_primitiveUnitType = CSS_VALUE_ID;
1973     switch (e) {
1974     case MCOLLAPSE:
1975         m_value.valueID = CSSValueCollapse;
1976         break;
1977     case MSEPARATE:
1978         m_value.valueID = CSSValueSeparate;
1979         break;
1980     case MDISCARD:
1981         m_value.valueID = CSSValueDiscard;
1982         break;
1983     }
1984 }
1985
1986 template<> inline CSSPrimitiveValue::operator EMarginCollapse() const
1987 {
1988     ASSERT(isValueID());
1989
1990     switch (m_value.valueID) {
1991     case CSSValueCollapse:
1992         return MCOLLAPSE;
1993     case CSSValueSeparate:
1994         return MSEPARATE;
1995     case CSSValueDiscard:
1996         return MDISCARD;
1997     default:
1998         break;
1999     }
2000
2001     ASSERT_NOT_REACHED();
2002     return MCOLLAPSE;
2003 }
2004
2005 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EMarqueeBehavior e)
2006     : CSSValue(PrimitiveClass)
2007 {
2008     m_primitiveUnitType = CSS_VALUE_ID;
2009     switch (e) {
2010     case MNONE:
2011         m_value.valueID = CSSValueNone;
2012         break;
2013     case MSCROLL:
2014         m_value.valueID = CSSValueScroll;
2015         break;
2016     case MSLIDE:
2017         m_value.valueID = CSSValueSlide;
2018         break;
2019     case MALTERNATE:
2020         m_value.valueID = CSSValueAlternate;
2021         break;
2022     }
2023 }
2024
2025 template<> inline CSSPrimitiveValue::operator EMarqueeBehavior() const
2026 {
2027     ASSERT(isValueID());
2028
2029     switch (m_value.valueID) {
2030     case CSSValueNone:
2031         return MNONE;
2032     case CSSValueScroll:
2033         return MSCROLL;
2034     case CSSValueSlide:
2035         return MSLIDE;
2036     case CSSValueAlternate:
2037         return MALTERNATE;
2038     default:
2039         break;
2040     }
2041
2042     ASSERT_NOT_REACHED();
2043     return MNONE;
2044 }
2045
2046 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(RegionFragment e)
2047     : CSSValue(PrimitiveClass)
2048 {
2049     m_primitiveUnitType = CSS_VALUE_ID;
2050     switch (e) {
2051     case AutoRegionFragment:
2052         m_value.valueID = CSSValueAuto;
2053         break;
2054     case BreakRegionFragment:
2055         m_value.valueID = CSSValueBreak;
2056         break;
2057     }
2058 }
2059
2060 template<> inline CSSPrimitiveValue::operator RegionFragment() const
2061 {
2062     ASSERT(isValueID());
2063
2064     switch (m_value.valueID) {
2065     case CSSValueAuto:
2066         return AutoRegionFragment;
2067     case CSSValueBreak:
2068         return BreakRegionFragment;
2069     default:
2070         break;
2071     }
2072
2073     ASSERT_NOT_REACHED();
2074     return AutoRegionFragment;
2075 }
2076
2077 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EMarqueeDirection e)
2078     : CSSValue(PrimitiveClass)
2079 {
2080     m_primitiveUnitType = CSS_VALUE_ID;
2081     switch (e) {
2082     case MFORWARD:
2083         m_value.valueID = CSSValueForwards;
2084         break;
2085     case MBACKWARD:
2086         m_value.valueID = CSSValueBackwards;
2087         break;
2088     case MAUTO:
2089         m_value.valueID = CSSValueAuto;
2090         break;
2091     case MUP:
2092         m_value.valueID = CSSValueUp;
2093         break;
2094     case MDOWN:
2095         m_value.valueID = CSSValueDown;
2096         break;
2097     case MLEFT:
2098         m_value.valueID = CSSValueLeft;
2099         break;
2100     case MRIGHT:
2101         m_value.valueID = CSSValueRight;
2102         break;
2103     }
2104 }
2105
2106 template<> inline CSSPrimitiveValue::operator EMarqueeDirection() const
2107 {
2108     ASSERT(isValueID());
2109
2110     switch (m_value.valueID) {
2111     case CSSValueForwards:
2112         return MFORWARD;
2113     case CSSValueBackwards:
2114         return MBACKWARD;
2115     case CSSValueAuto:
2116         return MAUTO;
2117     case CSSValueAhead:
2118     case CSSValueUp: // We don't support vertical languages, so AHEAD just maps to UP.
2119         return MUP;
2120     case CSSValueReverse:
2121     case CSSValueDown: // REVERSE just maps to DOWN, since we don't do vertical text.
2122         return MDOWN;
2123     case CSSValueLeft:
2124         return MLEFT;
2125     case CSSValueRight:
2126         return MRIGHT;
2127     default:
2128         break;
2129     }
2130
2131     ASSERT_NOT_REACHED();
2132     return MAUTO;
2133 }
2134
2135 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ENBSPMode e)
2136     : CSSValue(PrimitiveClass)
2137 {
2138     m_primitiveUnitType = CSS_VALUE_ID;
2139     switch (e) {
2140     case NBNORMAL:
2141         m_value.valueID = CSSValueNormal;
2142         break;
2143     case SPACE:
2144         m_value.valueID = CSSValueSpace;
2145         break;
2146     }
2147 }
2148
2149 template<> inline CSSPrimitiveValue::operator ENBSPMode() const
2150 {
2151     ASSERT(isValueID());
2152
2153     switch (m_value.valueID) {
2154     case CSSValueSpace:
2155         return SPACE;
2156     case CSSValueNormal:
2157         return NBNORMAL;
2158     default:
2159         break;
2160     }
2161
2162     ASSERT_NOT_REACHED();
2163     return NBNORMAL;
2164 }
2165
2166 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EOverflow e)
2167     : CSSValue(PrimitiveClass)
2168 {
2169     m_primitiveUnitType = CSS_VALUE_ID;
2170     switch (e) {
2171     case OVISIBLE:
2172         m_value.valueID = CSSValueVisible;
2173         break;
2174     case OHIDDEN:
2175         m_value.valueID = CSSValueHidden;
2176         break;
2177     case OSCROLL:
2178         m_value.valueID = CSSValueScroll;
2179         break;
2180     case OAUTO:
2181         m_value.valueID = CSSValueAuto;
2182         break;
2183     case OMARQUEE:
2184         m_value.valueID = CSSValueWebkitMarquee;
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 CSSValueWebkitMarquee:
2212         return OMARQUEE;
2213     case CSSValueOverlay:
2214         return OOVERLAY;
2215     case CSSValueWebkitPagedX:
2216         return OPAGEDX;
2217     case CSSValueWebkitPagedY:
2218         return OPAGEDY;
2219     default:
2220         break;
2221     }
2222
2223     ASSERT_NOT_REACHED();
2224     return OVISIBLE;
2225 }
2226
2227 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(BreakBetween e)
2228     : CSSValue(PrimitiveClass)
2229 {
2230     m_primitiveUnitType = CSS_VALUE_ID;
2231     switch (e) {
2232     case AutoBreakBetween:
2233         m_value.valueID = CSSValueAuto;
2234         break;
2235     case AvoidBreakBetween:
2236         m_value.valueID = CSSValueAvoid;
2237         break;
2238     case AvoidColumnBreakBetween:
2239         m_value.valueID = CSSValueAvoidColumn;
2240         break;
2241     case AvoidPageBreakBetween:
2242         m_value.valueID = CSSValueAvoidPage;
2243         break;
2244     case AvoidRegionBreakBetween:
2245         m_value.valueID = CSSValueAvoidRegion;
2246         break;
2247     case ColumnBreakBetween:
2248         m_value.valueID = CSSValueColumn;
2249         break;
2250     case PageBreakBetween:
2251         m_value.valueID = CSSValuePage;
2252         break;
2253     case RegionBreakBetween:
2254         m_value.valueID = CSSValueRegion;
2255         break;
2256     case LeftPageBreakBetween:
2257         m_value.valueID = CSSValueLeft;
2258         break;
2259     case RightPageBreakBetween:
2260         m_value.valueID = CSSValueRight;
2261         break;
2262     case RectoPageBreakBetween:
2263         m_value.valueID = CSSValueRecto;
2264         break;
2265     case VersoPageBreakBetween:
2266         m_value.valueID = CSSValueVerso;
2267         break;
2268     }
2269 }
2270
2271 template<> inline CSSPrimitiveValue::operator BreakBetween() const
2272 {
2273     ASSERT(isValueID());
2274
2275     switch (m_value.valueID) {
2276     case CSSValueAuto:
2277         return AutoBreakBetween;
2278     case CSSValueAvoid:
2279         return AvoidBreakBetween;
2280     case CSSValueAvoidColumn:
2281         return AvoidColumnBreakBetween;
2282     case CSSValueAvoidPage:
2283         return AvoidPageBreakBetween;
2284     case CSSValueAvoidRegion:
2285         return AvoidRegionBreakBetween;
2286     case CSSValueColumn:
2287         return ColumnBreakBetween;
2288     case CSSValuePage:
2289         return PageBreakBetween;
2290     case CSSValueRegion:
2291         return RegionBreakBetween;
2292     case CSSValueLeft:
2293         return LeftPageBreakBetween;
2294     case CSSValueRight:
2295         return RightPageBreakBetween;
2296     case CSSValueRecto:
2297         return RectoPageBreakBetween;
2298     case CSSValueVerso:
2299         return VersoPageBreakBetween;
2300     default:
2301         break;
2302     }
2303
2304     ASSERT_NOT_REACHED();
2305     return AutoBreakBetween;
2306 }
2307
2308 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(BreakInside e)
2309     : CSSValue(PrimitiveClass)
2310 {
2311     m_primitiveUnitType = CSS_VALUE_ID;
2312     switch (e) {
2313     case AutoBreakInside:
2314         m_value.valueID = CSSValueAuto;
2315         break;
2316     case AvoidBreakInside:
2317         m_value.valueID = CSSValueAvoid;
2318         break;
2319     case AvoidColumnBreakInside:
2320         m_value.valueID = CSSValueAvoidColumn;
2321         break;
2322     case AvoidPageBreakInside:
2323         m_value.valueID = CSSValueAvoidPage;
2324         break;
2325     case AvoidRegionBreakInside:
2326         m_value.valueID = CSSValueAvoidRegion;
2327         break;
2328     }
2329 }
2330
2331 template<> inline CSSPrimitiveValue::operator BreakInside() const
2332 {
2333     ASSERT(isValueID());
2334     
2335     switch (m_value.valueID) {
2336     case CSSValueAuto:
2337         return AutoBreakInside;
2338     case CSSValueAvoid:
2339         return AvoidBreakInside;
2340     case CSSValueAvoidColumn:
2341         return AvoidColumnBreakInside;
2342     case CSSValueAvoidPage:
2343         return AvoidPageBreakInside;
2344     case CSSValueAvoidRegion:
2345         return AvoidRegionBreakInside;
2346     default:
2347         break;
2348     }
2349
2350     ASSERT_NOT_REACHED();
2351     return AutoBreakInside;
2352 }
2353
2354 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EPosition e)
2355     : CSSValue(PrimitiveClass)
2356 {
2357     m_primitiveUnitType = CSS_VALUE_ID;
2358     switch (e) {
2359     case StaticPosition:
2360         m_value.valueID = CSSValueStatic;
2361         break;
2362     case RelativePosition:
2363         m_value.valueID = CSSValueRelative;
2364         break;
2365     case AbsolutePosition:
2366         m_value.valueID = CSSValueAbsolute;
2367         break;
2368     case FixedPosition:
2369         m_value.valueID = CSSValueFixed;
2370         break;
2371     case StickyPosition:
2372         m_value.valueID = CSSValueWebkitSticky;
2373         break;
2374     }
2375 }
2376
2377 template<> inline CSSPrimitiveValue::operator EPosition() const
2378 {
2379     ASSERT(isValueID());
2380
2381     switch (m_value.valueID) {
2382     case CSSValueStatic:
2383         return StaticPosition;
2384     case CSSValueRelative:
2385         return RelativePosition;
2386     case CSSValueAbsolute:
2387         return AbsolutePosition;
2388     case CSSValueFixed:
2389         return FixedPosition;
2390     case CSSValueWebkitSticky:
2391         return StickyPosition;
2392     default:
2393         break;
2394     }
2395
2396     ASSERT_NOT_REACHED();
2397     return StaticPosition;
2398 }
2399
2400 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EResize e)
2401     : CSSValue(PrimitiveClass)
2402 {
2403     m_primitiveUnitType = CSS_VALUE_ID;
2404     switch (e) {
2405     case RESIZE_BOTH:
2406         m_value.valueID = CSSValueBoth;
2407         break;
2408     case RESIZE_HORIZONTAL:
2409         m_value.valueID = CSSValueHorizontal;
2410         break;
2411     case RESIZE_VERTICAL:
2412         m_value.valueID = CSSValueVertical;
2413         break;
2414     case RESIZE_NONE:
2415         m_value.valueID = CSSValueNone;
2416         break;
2417     }
2418 }
2419
2420 template<> inline CSSPrimitiveValue::operator EResize() const
2421 {
2422     ASSERT(isValueID());
2423
2424     switch (m_value.valueID) {
2425     case CSSValueBoth:
2426         return RESIZE_BOTH;
2427     case CSSValueHorizontal:
2428         return RESIZE_HORIZONTAL;
2429     case CSSValueVertical:
2430         return RESIZE_VERTICAL;
2431     case CSSValueAuto:
2432         ASSERT_NOT_REACHED(); // Depends on settings, thus should be handled by the caller.
2433         return RESIZE_NONE;
2434     case CSSValueNone:
2435         return RESIZE_NONE;
2436     default:
2437         break;
2438     }
2439
2440     ASSERT_NOT_REACHED();
2441     return RESIZE_NONE;
2442 }
2443
2444 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETableLayout e)
2445     : CSSValue(PrimitiveClass)
2446 {
2447     m_primitiveUnitType = CSS_VALUE_ID;
2448     switch (e) {
2449     case TAUTO:
2450         m_value.valueID = CSSValueAuto;
2451         break;
2452     case TFIXED:
2453         m_value.valueID = CSSValueFixed;
2454         break;
2455     }
2456 }
2457
2458 template<> inline CSSPrimitiveValue::operator ETableLayout() const
2459 {
2460     ASSERT(isValueID());
2461
2462     switch (m_value.valueID) {
2463     case CSSValueFixed:
2464         return TFIXED;
2465     case CSSValueAuto:
2466         return TAUTO;
2467     default:
2468         break;
2469     }
2470
2471     ASSERT_NOT_REACHED();
2472     return TAUTO;
2473 }
2474
2475 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETextAlign e)
2476     : CSSValue(PrimitiveClass)
2477 {
2478     m_primitiveUnitType = CSS_VALUE_ID;
2479     switch (e) {
2480     case TASTART:
2481         m_value.valueID = CSSValueStart;
2482         break;
2483     case TAEND:
2484         m_value.valueID = CSSValueEnd;
2485         break;
2486     case LEFT:
2487         m_value.valueID = CSSValueLeft;
2488         break;
2489     case RIGHT:
2490         m_value.valueID = CSSValueRight;
2491         break;
2492     case CENTER:
2493         m_value.valueID = CSSValueCenter;
2494         break;
2495     case JUSTIFY:
2496         m_value.valueID = CSSValueJustify;
2497         break;
2498     case WEBKIT_LEFT:
2499         m_value.valueID = CSSValueWebkitLeft;
2500         break;
2501     case WEBKIT_RIGHT:
2502         m_value.valueID = CSSValueWebkitRight;
2503         break;
2504     case WEBKIT_CENTER:
2505         m_value.valueID = CSSValueWebkitCenter;
2506         break;
2507     }
2508 }
2509
2510 template<> inline CSSPrimitiveValue::operator ETextAlign() const
2511 {
2512     ASSERT(isValueID());
2513
2514     switch (m_value.valueID) {
2515     case CSSValueWebkitAuto: // Legacy -webkit-auto. Eqiuvalent to start.
2516     case CSSValueStart:
2517         return TASTART;
2518     case CSSValueEnd:
2519         return TAEND;
2520     default:
2521         return static_cast<ETextAlign>(m_value.valueID - CSSValueLeft);
2522     }
2523 }
2524
2525 #if ENABLE(CSS3_TEXT)
2526 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextAlignLast e)
2527     : CSSValue(PrimitiveClass)
2528 {
2529     m_primitiveUnitType = CSS_VALUE_ID;
2530     switch (e) {
2531     case TextAlignLastStart:
2532         m_value.valueID = CSSValueStart;
2533         break;
2534     case TextAlignLastEnd:
2535         m_value.valueID = CSSValueEnd;
2536         break;
2537     case TextAlignLastLeft:
2538         m_value.valueID = CSSValueLeft;
2539         break;
2540     case TextAlignLastRight:
2541         m_value.valueID = CSSValueRight;
2542         break;
2543     case TextAlignLastCenter:
2544         m_value.valueID = CSSValueCenter;
2545         break;
2546     case TextAlignLastJustify:
2547         m_value.valueID = CSSValueJustify;
2548         break;
2549     case TextAlignLastAuto:
2550         m_value.valueID = CSSValueAuto;
2551         break;
2552     }
2553 }
2554
2555 template<> inline CSSPrimitiveValue::operator TextAlignLast() const
2556 {
2557     ASSERT(isValueID());
2558
2559     switch (m_value.valueID) {
2560     case CSSValueAuto:
2561         return TextAlignLastAuto;
2562     case CSSValueStart:
2563         return TextAlignLastStart;
2564     case CSSValueEnd:
2565         return TextAlignLastEnd;
2566     case CSSValueLeft:
2567         return TextAlignLastLeft;
2568     case CSSValueRight:
2569         return TextAlignLastRight;
2570     case CSSValueCenter:
2571         return TextAlignLastCenter;
2572     case CSSValueJustify:
2573         return TextAlignLastJustify;
2574     default:
2575         break;
2576     }
2577
2578     ASSERT_NOT_REACHED();
2579     return TextAlignLastAuto;
2580 }
2581
2582 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextJustify e)
2583     : CSSValue(PrimitiveClass)
2584 {
2585     m_primitiveUnitType = CSS_VALUE_ID;
2586     switch (e) {
2587     case TextJustifyAuto:
2588         m_value.valueID = CSSValueAuto;
2589         break;
2590     case TextJustifyNone:
2591         m_value.valueID = CSSValueNone;
2592         break;
2593     case TextJustifyInterWord:
2594         m_value.valueID = CSSValueInterWord;
2595         break;
2596     case TextJustifyDistribute:
2597         m_value.valueID = CSSValueDistribute;
2598         break;
2599     }
2600 }
2601
2602 template<> inline CSSPrimitiveValue::operator TextJustify() const
2603 {
2604     ASSERT(isValueID());
2605
2606     switch (m_value.valueID) {
2607     case CSSValueAuto:
2608         return TextJustifyAuto;
2609     case CSSValueNone:
2610         return TextJustifyNone;
2611     case CSSValueInterWord:
2612         return TextJustifyInterWord;
2613     case CSSValueDistribute:
2614         return TextJustifyDistribute;
2615     default:
2616         break;
2617     }
2618
2619     ASSERT_NOT_REACHED();
2620     return TextJustifyAuto;
2621 }
2622 #endif // CSS3_TEXT
2623
2624 template<> inline CSSPrimitiveValue::operator TextDecoration() const
2625 {
2626     ASSERT(isValueID());
2627
2628     switch (m_value.valueID) {
2629     case CSSValueNone:
2630         return TextDecorationNone;
2631     case CSSValueUnderline:
2632         return TextDecorationUnderline;
2633     case CSSValueOverline:
2634         return TextDecorationOverline;
2635     case CSSValueLineThrough:
2636         return TextDecorationLineThrough;
2637     case CSSValueBlink:
2638         return TextDecorationBlink;
2639 #if ENABLE(LETTERPRESS)
2640     case CSSValueWebkitLetterpress:
2641         return TextDecorationLetterpress;
2642 #endif
2643     default:
2644         break;
2645     }
2646
2647     ASSERT_NOT_REACHED();
2648     return TextDecorationNone;
2649 }
2650
2651 template<> inline CSSPrimitiveValue::operator TextDecorationStyle() const
2652 {
2653     ASSERT(isValueID());
2654
2655     switch (m_value.valueID) {
2656     case CSSValueSolid:
2657         return TextDecorationStyleSolid;
2658     case CSSValueDouble:
2659         return TextDecorationStyleDouble;
2660     case CSSValueDotted:
2661         return TextDecorationStyleDotted;
2662     case CSSValueDashed:
2663         return TextDecorationStyleDashed;
2664     case CSSValueWavy:
2665         return TextDecorationStyleWavy;
2666     default:
2667         break;
2668     }
2669
2670     ASSERT_NOT_REACHED();
2671     return TextDecorationStyleSolid;
2672 }
2673
2674 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextUnderlinePosition e)
2675     : CSSValue(PrimitiveClass)
2676 {
2677     m_primitiveUnitType = CSS_VALUE_ID;
2678     switch (e) {
2679     case TextUnderlinePositionAuto:
2680         m_value.valueID = CSSValueAuto;
2681         break;
2682     case TextUnderlinePositionAlphabetic:
2683         m_value.valueID = CSSValueAlphabetic;
2684         break;
2685     case TextUnderlinePositionUnder:
2686         m_value.valueID = CSSValueUnder;
2687         break;
2688     }
2689
2690     // FIXME: Implement support for 'under left' and 'under right' values.
2691 }
2692
2693 template<> inline CSSPrimitiveValue::operator TextUnderlinePosition() const
2694 {
2695     ASSERT(isValueID());
2696
2697     switch (m_value.valueID) {
2698     case CSSValueAuto:
2699         return TextUnderlinePositionAuto;
2700     case CSSValueAlphabetic:
2701         return TextUnderlinePositionAlphabetic;
2702     case CSSValueUnder:
2703         return TextUnderlinePositionUnder;
2704     default:
2705         break;
2706     }
2707
2708     // FIXME: Implement support for 'under left' and 'under right' values.
2709
2710     ASSERT_NOT_REACHED();
2711     return TextUnderlinePositionAuto;
2712 }
2713
2714 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETextSecurity e)
2715     : CSSValue(PrimitiveClass)
2716 {
2717     m_primitiveUnitType = CSS_VALUE_ID;
2718     switch (e) {
2719     case TSNONE:
2720         m_value.valueID = CSSValueNone;
2721         break;
2722     case TSDISC:
2723         m_value.valueID = CSSValueDisc;
2724         break;
2725     case TSCIRCLE:
2726         m_value.valueID = CSSValueCircle;
2727         break;
2728     case TSSQUARE:
2729         m_value.valueID = CSSValueSquare;
2730         break;
2731     }
2732 }
2733
2734 template<> inline CSSPrimitiveValue::operator ETextSecurity() const
2735 {
2736     ASSERT(isValueID());
2737
2738     switch (m_value.valueID) {
2739     case CSSValueNone:
2740         return TSNONE;
2741     case CSSValueDisc:
2742         return TSDISC;
2743     case CSSValueCircle:
2744         return TSCIRCLE;
2745     case CSSValueSquare:
2746         return TSSQUARE;
2747     default:
2748         break;
2749     }
2750
2751     ASSERT_NOT_REACHED();
2752     return TSNONE;
2753 }
2754
2755 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETextTransform e)
2756     : CSSValue(PrimitiveClass)
2757 {
2758     m_primitiveUnitType = CSS_VALUE_ID;
2759     switch (e) {
2760     case CAPITALIZE:
2761         m_value.valueID = CSSValueCapitalize;
2762         break;
2763     case UPPERCASE:
2764         m_value.valueID = CSSValueUppercase;
2765         break;
2766     case LOWERCASE:
2767         m_value.valueID = CSSValueLowercase;
2768         break;
2769     case TTNONE:
2770         m_value.valueID = CSSValueNone;
2771         break;
2772     }
2773 }
2774
2775 template<> inline CSSPrimitiveValue::operator ETextTransform() const
2776 {
2777     ASSERT(isValueID());
2778
2779     switch (m_value.valueID) {
2780     case CSSValueCapitalize:
2781         return CAPITALIZE;
2782     case CSSValueUppercase:
2783         return UPPERCASE;
2784     case CSSValueLowercase:
2785         return LOWERCASE;
2786     case CSSValueNone:
2787         return TTNONE;
2788     default:
2789         break;
2790     }
2791
2792     ASSERT_NOT_REACHED();
2793     return TTNONE;
2794 }
2795
2796 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUnicodeBidi e)
2797     : CSSValue(PrimitiveClass)
2798 {
2799     m_primitiveUnitType = CSS_VALUE_ID;
2800     switch (e) {
2801     case UBNormal:
2802         m_value.valueID = CSSValueNormal;
2803         break;
2804     case Embed:
2805         m_value.valueID = CSSValueEmbed;
2806         break;
2807     case Override:
2808         m_value.valueID = CSSValueBidiOverride;
2809         break;
2810     case Isolate:
2811         m_value.valueID = CSSValueWebkitIsolate;
2812         break;
2813     case IsolateOverride:
2814         m_value.valueID = CSSValueWebkitIsolateOverride;
2815         break;
2816     case Plaintext:
2817         m_value.valueID = CSSValueWebkitPlaintext;
2818         break;
2819     }
2820 }
2821
2822 template<> inline CSSPrimitiveValue::operator EUnicodeBidi() const
2823 {
2824     ASSERT(isValueID());
2825
2826     switch (m_value.valueID) {
2827     case CSSValueNormal:
2828         return UBNormal;
2829     case CSSValueEmbed:
2830         return Embed;
2831     case CSSValueBidiOverride:
2832         return Override;
2833     case CSSValueWebkitIsolate:
2834         return Isolate;
2835     case CSSValueWebkitIsolateOverride:
2836         return IsolateOverride;
2837     case CSSValueWebkitPlaintext:
2838         return Plaintext;
2839     default:
2840         break;
2841     }
2842
2843     ASSERT_NOT_REACHED();
2844     return UBNormal;
2845 }
2846
2847 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUserDrag e)
2848     : CSSValue(PrimitiveClass)
2849 {
2850     m_primitiveUnitType = CSS_VALUE_ID;
2851     switch (e) {
2852     case DRAG_AUTO:
2853         m_value.valueID = CSSValueAuto;
2854         break;
2855     case DRAG_NONE:
2856         m_value.valueID = CSSValueNone;
2857         break;
2858     case DRAG_ELEMENT:
2859         m_value.valueID = CSSValueElement;
2860         break;
2861     default:
2862         break;
2863     }
2864 }
2865
2866 template<> inline CSSPrimitiveValue::operator EUserDrag() const
2867 {
2868     ASSERT(isValueID());
2869
2870     switch (m_value.valueID) {
2871     case CSSValueAuto:
2872         return DRAG_AUTO;
2873     case CSSValueNone:
2874         return DRAG_NONE;
2875     case CSSValueElement:
2876         return DRAG_ELEMENT;
2877     default:
2878         break;
2879     }
2880
2881     ASSERT_NOT_REACHED();
2882     return DRAG_AUTO;
2883 }
2884
2885 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUserModify e)
2886     : CSSValue(PrimitiveClass)
2887 {
2888     m_primitiveUnitType = CSS_VALUE_ID;
2889     switch (e) {
2890     case READ_ONLY:
2891         m_value.valueID = CSSValueReadOnly;
2892         break;
2893     case READ_WRITE:
2894         m_value.valueID = CSSValueReadWrite;
2895         break;
2896     case READ_WRITE_PLAINTEXT_ONLY:
2897         m_value.valueID = CSSValueReadWritePlaintextOnly;
2898         break;
2899     }
2900 }
2901
2902 template<> inline CSSPrimitiveValue::operator EUserModify() const
2903 {
2904     ASSERT(isValueID());
2905
2906     switch (m_value.valueID) {
2907     case CSSValueReadOnly:
2908         return READ_ONLY;
2909     case CSSValueReadWrite:
2910         return READ_WRITE;
2911     case CSSValueReadWritePlaintextOnly:
2912         return READ_WRITE_PLAINTEXT_ONLY;
2913     default:
2914         break;
2915     }
2916
2917     ASSERT_NOT_REACHED();
2918     return READ_ONLY;
2919 }
2920
2921 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUserSelect e)
2922     : CSSValue(PrimitiveClass)
2923 {
2924     m_primitiveUnitType = CSS_VALUE_ID;
2925     switch (e) {
2926     case SELECT_NONE:
2927         m_value.valueID = CSSValueNone;
2928         break;
2929     case SELECT_TEXT:
2930         m_value.valueID = CSSValueText;
2931         break;
2932     case SELECT_ALL:
2933         m_value.valueID = CSSValueAll;
2934         break;
2935     }
2936 }
2937
2938 template<> inline CSSPrimitiveValue::operator EUserSelect() const
2939 {
2940     ASSERT(isValueID());
2941
2942     switch (m_value.valueID) {
2943     case CSSValueAuto:
2944         return SELECT_TEXT;
2945     case CSSValueNone:
2946         return SELECT_NONE;
2947     case CSSValueText:
2948         return SELECT_TEXT;
2949     case CSSValueAll:
2950         return SELECT_ALL;
2951     default:
2952         break;
2953     }
2954
2955     ASSERT_NOT_REACHED();
2956     return SELECT_TEXT;
2957 }
2958
2959 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EVerticalAlign a)
2960     : CSSValue(PrimitiveClass)
2961 {
2962     m_primitiveUnitType = CSS_VALUE_ID;
2963     switch (a) {
2964     case TOP:
2965         m_value.valueID = CSSValueTop;
2966         break;
2967     case BOTTOM:
2968         m_value.valueID = CSSValueBottom;
2969         break;
2970     case MIDDLE:
2971         m_value.valueID = CSSValueMiddle;
2972         break;
2973     case BASELINE:
2974         m_value.valueID = CSSValueBaseline;
2975         break;
2976     case TEXT_BOTTOM:
2977         m_value.valueID = CSSValueTextBottom;
2978         break;
2979     case TEXT_TOP:
2980         m_value.valueID = CSSValueTextTop;
2981         break;
2982     case SUB:
2983         m_value.valueID = CSSValueSub;
2984         break;
2985     case SUPER:
2986         m_value.valueID = CSSValueSuper;
2987         break;
2988     case BASELINE_MIDDLE:
2989         m_value.valueID = CSSValueWebkitBaselineMiddle;
2990         break;
2991     case LENGTH:
2992         m_value.valueID = CSSValueInvalid;
2993     }
2994 }
2995
2996 template<> inline CSSPrimitiveValue::operator EVerticalAlign() const
2997 {
2998     ASSERT(isValueID());
2999
3000     switch (m_value.valueID) {
3001     case CSSValueTop:
3002         return TOP;
3003     case CSSValueBottom:
3004         return BOTTOM;
3005     case CSSValueMiddle:
3006         return MIDDLE;
3007     case CSSValueBaseline:
3008         return BASELINE;
3009     case CSSValueTextBottom:
3010         return TEXT_BOTTOM;
3011     case CSSValueTextTop:
3012         return TEXT_TOP;
3013     case CSSValueSub:
3014         return SUB;
3015     case CSSValueSuper:
3016         return SUPER;
3017     case CSSValueWebkitBaselineMiddle:
3018         return BASELINE_MIDDLE;
3019     default:
3020         break;
3021     }
3022
3023     ASSERT_NOT_REACHED();
3024     return TOP;
3025 }
3026
3027 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EVisibility e)
3028     : CSSValue(PrimitiveClass)
3029 {
3030     m_primitiveUnitType = CSS_VALUE_ID;
3031     switch (e) {
3032     case VISIBLE:
3033         m_value.valueID = CSSValueVisible;
3034         break;
3035     case HIDDEN:
3036         m_value.valueID = CSSValueHidden;
3037         break;
3038     case COLLAPSE:
3039         m_value.valueID = CSSValueCollapse;
3040         break;
3041     }
3042 }
3043
3044 template<> inline CSSPrimitiveValue::operator EVisibility() const
3045 {
3046     ASSERT(isValueID());
3047
3048     switch (m_value.valueID) {
3049     case CSSValueHidden:
3050         return HIDDEN;
3051     case CSSValueVisible:
3052         return VISIBLE;
3053     case CSSValueCollapse:
3054         return COLLAPSE;
3055     default:
3056         break;
3057     }
3058
3059     ASSERT_NOT_REACHED();
3060     return VISIBLE;
3061 }
3062
3063 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EWhiteSpace e)
3064     : CSSValue(PrimitiveClass)
3065 {
3066     m_primitiveUnitType = CSS_VALUE_ID;
3067     switch (e) {
3068     case NORMAL:
3069         m_value.valueID = CSSValueNormal;
3070         break;
3071     case PRE:
3072         m_value.valueID = CSSValuePre;
3073         break;
3074     case PRE_WRAP:
3075         m_value.valueID = CSSValuePreWrap;
3076         break;
3077     case PRE_LINE:
3078         m_value.valueID = CSSValuePreLine;
3079         break;
3080     case NOWRAP:
3081         m_value.valueID = CSSValueNowrap;
3082         break;
3083     case KHTML_NOWRAP:
3084         m_value.valueID = CSSValueWebkitNowrap;
3085         break;
3086     }
3087 }
3088
3089 template<> inline CSSPrimitiveValue::operator EWhiteSpace() const
3090 {
3091     ASSERT(isValueID());
3092
3093     switch (m_value.valueID) {
3094     case CSSValueWebkitNowrap:
3095         return KHTML_NOWRAP;
3096     case CSSValueNowrap:
3097         return NOWRAP;
3098     case CSSValuePre:
3099         return PRE;
3100     case CSSValuePreWrap:
3101         return PRE_WRAP;
3102     case CSSValuePreLine:
3103         return PRE_LINE;
3104     case CSSValueNormal:
3105         return NORMAL;
3106     default:
3107         break;
3108     }
3109
3110     ASSERT_NOT_REACHED();
3111     return NORMAL;
3112 }
3113
3114 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EWordBreak e)
3115     : CSSValue(PrimitiveClass)
3116 {
3117     m_primitiveUnitType = CSS_VALUE_ID;
3118     switch (e) {
3119     case NormalWordBreak:
3120         m_value.valueID = CSSValueNormal;
3121         break;
3122     case BreakAllWordBreak:
3123         m_value.valueID = CSSValueBreakAll;
3124         break;
3125     case KeepAllWordBreak:
3126         m_value.valueID = CSSValueKeepAll;
3127         break;
3128     case BreakWordBreak:
3129         m_value.valueID = CSSValueBreakWord;
3130         break;
3131     }
3132 }
3133
3134 template<> inline CSSPrimitiveValue::operator EWordBreak() const
3135 {
3136     ASSERT(isValueID());
3137
3138     switch (m_value.valueID) {
3139     case CSSValueBreakAll:
3140         return BreakAllWordBreak;
3141     case CSSValueKeepAll:
3142         return KeepAllWordBreak;
3143     case CSSValueBreakWord:
3144         return BreakWordBreak;
3145     case CSSValueNormal:
3146         return NormalWordBreak;
3147     default:
3148         break;
3149     }
3150
3151     ASSERT_NOT_REACHED();
3152     return NormalWordBreak;
3153 }
3154
3155 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EOverflowWrap e)
3156     : CSSValue(PrimitiveClass)
3157 {
3158     m_primitiveUnitType = CSS_VALUE_ID;
3159     switch (e) {
3160     case NormalOverflowWrap:
3161         m_value.valueID = CSSValueNormal;
3162         break;
3163     case BreakOverflowWrap:
3164         m_value.valueID = CSSValueBreakWord;
3165         break;
3166     }
3167 }
3168
3169 template<> inline CSSPrimitiveValue::operator EOverflowWrap() const
3170 {
3171     ASSERT(isValueID());
3172
3173     switch (m_value.valueID) {
3174     case CSSValueBreakWord:
3175         return BreakOverflowWrap;
3176     case CSSValueNormal:
3177         return NormalOverflowWrap;
3178     default:
3179         break;
3180     }
3181
3182     ASSERT_NOT_REACHED();
3183     return NormalOverflowWrap;
3184 }
3185
3186 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextDirection e)
3187     : CSSValue(PrimitiveClass)
3188 {
3189     m_primitiveUnitType = CSS_VALUE_ID;
3190     switch (e) {
3191     case LTR:
3192         m_value.valueID = CSSValueLtr;
3193         break;
3194     case RTL:
3195         m_value.valueID = CSSValueRtl;
3196         break;
3197     }
3198 }
3199
3200 template<> inline CSSPrimitiveValue::operator TextDirection() const
3201 {
3202     ASSERT(isValueID());
3203
3204     switch (m_value.valueID) {
3205     case CSSValueLtr:
3206         return LTR;
3207     case CSSValueRtl:
3208         return RTL;
3209     default:
3210         break;
3211     }
3212
3213     ASSERT_NOT_REACHED();
3214     return LTR;
3215 }
3216
3217 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(WritingMode e)
3218     : CSSValue(PrimitiveClass)
3219 {
3220     m_primitiveUnitType = CSS_VALUE_ID;
3221     switch (e) {
3222     case TopToBottomWritingMode:
3223         m_value.valueID = CSSValueHorizontalTb;
3224         break;
3225     case RightToLeftWritingMode:
3226         m_value.valueID = CSSValueVerticalRl;
3227         break;
3228     case LeftToRightWritingMode:
3229         m_value.valueID = CSSValueVerticalLr;
3230         break;
3231     case BottomToTopWritingMode:
3232         m_value.valueID = CSSValueHorizontalBt;
3233         break;
3234     }
3235 }
3236
3237 template<> inline CSSPrimitiveValue::operator WritingMode() const
3238 {
3239     ASSERT(isValueID());
3240
3241     switch (m_value.valueID) {
3242     case CSSValueHorizontalTb:
3243         return TopToBottomWritingMode;
3244     case CSSValueVerticalRl:
3245         return RightToLeftWritingMode;
3246     case CSSValueVerticalLr:
3247         return LeftToRightWritingMode;
3248     case CSSValueHorizontalBt:
3249         return BottomToTopWritingMode;
3250     default:
3251         break;
3252     }
3253
3254     ASSERT_NOT_REACHED();
3255     return TopToBottomWritingMode;
3256 }
3257
3258 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextCombine e)
3259     : CSSValue(PrimitiveClass)
3260 {
3261     m_primitiveUnitType = CSS_VALUE_ID;
3262     switch (e) {
3263     case TextCombineNone:
3264         m_value.valueID = CSSValueNone;
3265         break;
3266     case TextCombineHorizontal:
3267         m_value.valueID = CSSValueHorizontal;
3268         break;
3269     }
3270 }
3271
3272 template<> inline CSSPrimitiveValue::operator TextCombine() const
3273 {
3274     ASSERT(isValueID());
3275
3276     switch (m_value.valueID) {
3277     case CSSValueNone:
3278         return TextCombineNone;
3279     case CSSValueHorizontal:
3280         return TextCombineHorizontal;
3281     default:
3282         break;
3283     }
3284
3285     ASSERT_NOT_REACHED();
3286     return TextCombineNone;
3287 }
3288
3289 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(RubyPosition position)
3290     : CSSValue(PrimitiveClass)
3291 {
3292     m_primitiveUnitType = CSS_VALUE_ID;
3293     switch (position) {
3294     case RubyPositionBefore:
3295         m_value.valueID = CSSValueBefore;
3296         break;
3297     case RubyPositionAfter:
3298         m_value.valueID = CSSValueAfter;
3299         break;
3300     case RubyPositionInterCharacter:
3301         m_value.valueID = CSSValueInterCharacter;
3302         break;
3303     }
3304 }
3305
3306 template<> inline CSSPrimitiveValue::operator RubyPosition() const
3307 {
3308     ASSERT(isValueID());
3309
3310     switch (m_value.valueID) {
3311     case CSSValueBefore:
3312         return RubyPositionBefore;
3313     case CSSValueAfter:
3314         return RubyPositionAfter;
3315     case CSSValueInterCharacter:
3316         return RubyPositionInterCharacter;
3317     default:
3318         break;
3319     }
3320
3321     ASSERT_NOT_REACHED();
3322     return RubyPositionBefore;
3323 }
3324
3325 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextOverflow overflow)
3326     : CSSValue(PrimitiveClass)
3327 {
3328     m_primitiveUnitType = CSS_VALUE_ID;
3329     switch (overflow) {
3330     case TextOverflowClip:
3331         m_value.valueID = CSSValueClip;
3332         break;
3333     case TextOverflowEllipsis:
3334         m_value.valueID = CSSValueEllipsis;
3335         break;
3336     }
3337 }
3338
3339 template<> inline CSSPrimitiveValue::operator TextOverflow() const
3340 {
3341     ASSERT(isValueID());
3342
3343     switch (m_value.valueID) {
3344     case CSSValueClip:
3345         return TextOverflowClip;
3346     case CSSValueEllipsis:
3347         return TextOverflowEllipsis;
3348     default:
3349         break;
3350     }
3351
3352     ASSERT_NOT_REACHED();
3353     return TextOverflowClip;
3354 }
3355
3356 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextEmphasisFill fill)
3357     : CSSValue(PrimitiveClass)
3358 {
3359     m_primitiveUnitType = CSS_VALUE_ID;
3360     switch (fill) {
3361     case TextEmphasisFillFilled:
3362         m_value.valueID = CSSValueFilled;
3363         break;
3364     case TextEmphasisFillOpen:
3365         m_value.valueID = CSSValueOpen;
3366         break;
3367     }
3368 }
3369
3370 template<> inline CSSPrimitiveValue::operator TextEmphasisFill() const
3371 {
3372     ASSERT(isValueID());
3373
3374     switch (m_value.valueID) {
3375     case CSSValueFilled:
3376         return TextEmphasisFillFilled;
3377     case CSSValueOpen:
3378         return TextEmphasisFillOpen;
3379     default:
3380         break;
3381     }
3382
3383     ASSERT_NOT_REACHED();
3384     return TextEmphasisFillFilled;
3385 }
3386
3387 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextEmphasisMark mark)
3388     : CSSValue(PrimitiveClass)
3389 {
3390     m_primitiveUnitType = CSS_VALUE_ID;
3391     switch (mark) {
3392     case TextEmphasisMarkDot:
3393         m_value.valueID = CSSValueDot;
3394         break;
3395     case TextEmphasisMarkCircle:
3396         m_value.valueID = CSSValueCircle;
3397         break;
3398     case TextEmphasisMarkDoubleCircle:
3399         m_value.valueID = CSSValueDoubleCircle;
3400         break;
3401     case TextEmphasisMarkTriangle:
3402         m_value.valueID = CSSValueTriangle;
3403         break;
3404     case TextEmphasisMarkSesame:
3405         m_value.valueID = CSSValueSesame;
3406         break;
3407     case TextEmphasisMarkNone:
3408     case TextEmphasisMarkAuto:
3409     case TextEmphasisMarkCustom:
3410         ASSERT_NOT_REACHED();
3411         m_value.valueID = CSSValueNone;
3412         break;
3413     }
3414 }
3415
3416 template<> inline CSSPrimitiveValue::operator TextEmphasisMark() const
3417 {
3418     ASSERT(isValueID());
3419
3420     switch (m_value.valueID) {
3421     case CSSValueNone:
3422         return TextEmphasisMarkNone;
3423     case CSSValueDot:
3424         return TextEmphasisMarkDot;
3425     case CSSValueCircle:
3426         return TextEmphasisMarkCircle;
3427     case CSSValueDoubleCircle:
3428         return TextEmphasisMarkDoubleCircle;
3429     case CSSValueTriangle:
3430         return TextEmphasisMarkTriangle;
3431     case CSSValueSesame:
3432         return TextEmphasisMarkSesame;
3433     default:
3434         break;
3435     }
3436
3437     ASSERT_NOT_REACHED();
3438     return TextEmphasisMarkNone;
3439 }
3440
3441 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextOrientation e)
3442     : CSSValue(PrimitiveClass)
3443 {
3444     m_primitiveUnitType = CSS_VALUE_ID;
3445     switch (e) {
3446     case TextOrientation::Sideways:
3447         m_value.valueID = CSSValueSideways;
3448         break;
3449     case TextOrientation::Mixed:
3450         m_value.valueID = CSSValueMixed;
3451         break;
3452     case TextOrientation::Upright:
3453         m_value.valueID = CSSValueUpright;
3454         break;
3455     }
3456 }
3457
3458 template<> inline CSSPrimitiveValue::operator TextOrientation() const
3459 {
3460     ASSERT(isValueID());
3461
3462     switch (m_value.valueID) {
3463     case CSSValueSideways:
3464         return TextOrientation::Sideways;
3465     case CSSValueSidewaysRight:
3466         return TextOrientation::Sideways;
3467     case CSSValueVerticalRight:
3468         return TextOrientation::Mixed;
3469     case CSSValueMixed:
3470         return TextOrientation::Mixed;
3471     case CSSValueUpright:
3472         return TextOrientation::Upright;
3473     default:
3474         break;
3475     }
3476
3477     ASSERT_NOT_REACHED();
3478     return TextOrientation::Mixed;
3479 }
3480
3481 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EPointerEvents e)
3482     : CSSValue(PrimitiveClass)
3483 {
3484     m_primitiveUnitType = CSS_VALUE_ID;
3485     switch (e) {
3486     case PE_NONE:
3487         m_value.valueID = CSSValueNone;
3488         break;
3489     case PE_STROKE:
3490         m_value.valueID = CSSValueStroke;
3491         break;
3492     case PE_FILL:
3493         m_value.valueID = CSSValueFill;
3494         break;
3495     case PE_PAINTED:
3496         m_value.valueID = CSSValuePainted;
3497         break;
3498     case PE_VISIBLE:
3499         m_value.valueID = CSSValueVisible;
3500         break;
3501     case PE_VISIBLE_STROKE:
3502         m_value.valueID = CSSValueVisiblestroke;
3503         break;
3504     case PE_VISIBLE_FILL:
3505         m_value.valueID = CSSValueVisiblefill;
3506         break;
3507     case PE_VISIBLE_PAINTED:
3508         m_value.valueID = CSSValueVisiblepainted;
3509         break;
3510     case PE_AUTO:
3511         m_value.valueID = CSSValueAuto;
3512         break;
3513     case PE_ALL:
3514         m_value.valueID = CSSValueAll;
3515         break;
3516     }
3517 }
3518
3519 template<> inline CSSPrimitiveValue::operator EPointerEvents() const
3520 {
3521     ASSERT(isValueID());
3522
3523     switch (m_value.valueID) {
3524     case CSSValueAll:
3525         return PE_ALL;
3526     case CSSValueAuto:
3527         return PE_AUTO;
3528     case CSSValueNone:
3529         return PE_NONE;
3530     case CSSValueVisiblepainted:
3531         return PE_VISIBLE_PAINTED;
3532     case CSSValueVisiblefill:
3533         return PE_VISIBLE_FILL;
3534     case CSSValueVisiblestroke:
3535         return PE_VISIBLE_STROKE;
3536     case CSSValueVisible:
3537         return PE_VISIBLE;
3538     case CSSValuePainted:
3539         return PE_PAINTED;
3540     case CSSValueFill:
3541         return PE_FILL;
3542     case CSSValueStroke:
3543         return PE_STROKE;
3544     default:
3545         break;
3546     }
3547
3548     ASSERT_NOT_REACHED();
3549     return PE_ALL;
3550 }
3551
3552 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(Kerning kerning)
3553     : CSSValue(PrimitiveClass)
3554 {
3555     m_primitiveUnitType = CSS_VALUE_ID;
3556     switch (kerning) {
3557     case Kerning::Auto:
3558         m_value.valueID = CSSValueAuto;
3559         return;
3560     case Kerning::Normal:
3561         m_value.valueID = CSSValueNormal;
3562         return;
3563     case Kerning::NoShift:
3564         m_value.valueID = CSSValueNone;
3565         return;
3566     }
3567
3568     ASSERT_NOT_REACHED();
3569     m_value.valueID = CSSValueAuto;
3570 }
3571
3572 template<> inline CSSPrimitiveValue::operator Kerning() const
3573 {
3574     ASSERT(isValueID());
3575
3576     switch (m_value.valueID) {
3577     case CSSValueAuto:
3578         return Kerning::Auto;
3579     case CSSValueNormal:
3580         return Kerning::Normal;
3581     case CSSValueNone:
3582         return Kerning::NoShift;
3583     default:
3584         break;
3585     }
3586
3587     ASSERT_NOT_REACHED();
3588     return Kerning::Auto;
3589 }
3590
3591 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ObjectFit fit)
3592     : CSSValue(PrimitiveClass)
3593 {
3594     m_primitiveUnitType = CSS_VALUE_ID;
3595     switch (fit) {
3596     case ObjectFitFill:
3597         m_value.valueID = CSSValueFill;
3598         break;
3599     case ObjectFitContain:
3600         m_value.valueID = CSSValueContain;
3601         break;
3602     case ObjectFitCover:
3603         m_value.valueID = CSSValueCover;
3604         break;
3605     case ObjectFitNone:
3606         m_value.valueID = CSSValueNone;
3607         break;
3608     case ObjectFitScaleDown:
3609         m_value.valueID = CSSValueScaleDown;
3610         break;
3611     }
3612 }
3613
3614 template<> inline CSSPrimitiveValue::operator ObjectFit() const
3615 {
3616     ASSERT(isValueID());
3617
3618     switch (m_value.valueID) {
3619     case CSSValueFill:
3620         return ObjectFitFill;
3621     case CSSValueContain:
3622         return ObjectFitContain;
3623     case CSSValueCover:
3624         return ObjectFitCover;
3625     case CSSValueNone:
3626         return ObjectFitNone;
3627     case CSSValueScaleDown:
3628         return ObjectFitScaleDown;
3629     default:
3630         ASSERT_NOT_REACHED();
3631         return ObjectFitFill;
3632     }
3633 }
3634
3635 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontSmoothingMode smoothing)
3636     : CSSValue(PrimitiveClass)
3637 {
3638     m_primitiveUnitType = CSS_VALUE_ID;
3639     switch (smoothing) {
3640     case AutoSmoothing:
3641         m_value.valueID = CSSValueAuto;
3642         return;
3643     case NoSmoothing:
3644         m_value.valueID = CSSValueNone;
3645         return;
3646     case Antialiased:
3647         m_value.valueID = CSSValueAntialiased;
3648         return;
3649     case SubpixelAntialiased:
3650         m_value.valueID = CSSValueSubpixelAntialiased;
3651         return;
3652     }
3653
3654     ASSERT_NOT_REACHED();
3655     m_value.valueID = CSSValueAuto;
3656 }
3657
3658 template<> inline CSSPrimitiveValue::operator FontSmoothingMode() const
3659 {
3660     ASSERT(isValueID());
3661
3662     switch (m_value.valueID) {
3663     case CSSValueAuto:
3664         return AutoSmoothing;
3665     case CSSValueNone:
3666         return NoSmoothing;
3667     case CSSValueAntialiased:
3668         return Antialiased;
3669     case CSSValueSubpixelAntialiased:
3670         return SubpixelAntialiased;
3671     default:
3672         break;
3673     }
3674
3675     ASSERT_NOT_REACHED();
3676     return AutoSmoothing;
3677 }
3678
3679 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontWeight weight)
3680     : CSSValue(PrimitiveClass)
3681 {
3682     m_primitiveUnitType = CSS_VALUE_ID;
3683     switch (weight) {
3684     case FontWeight900:
3685         m_value.valueID = CSSValue900;
3686         return;
3687     case FontWeight800:
3688         m_value.valueID = CSSValue800;
3689         return;
3690     case FontWeight700:
3691         m_value.valueID = CSSValue700;
3692         return;
3693     case FontWeight600:
3694         m_value.valueID = CSSValue600;
3695         return;
3696     case FontWeight500:
3697         m_value.valueID = CSSValue500;
3698         return;
3699     case FontWeight400:
3700         m_value.valueID = CSSValue400;
3701         return;
3702     case FontWeight300:
3703         m_value.valueID = CSSValue300;
3704         return;
3705     case FontWeight200:
3706         m_value.valueID = CSSValue200;
3707         return;
3708     case FontWeight100:
3709         m_value.valueID = CSSValue100;
3710         return;
3711     }
3712
3713     ASSERT_NOT_REACHED();
3714     m_value.valueID = CSSValueNormal;
3715 }
3716
3717 template<> inline CSSPrimitiveValue::operator FontWeight() const
3718 {
3719     ASSERT(isValueID());
3720
3721     switch (m_value.valueID) {
3722     case CSSValueBold:
3723         return FontWeightBold;
3724     case CSSValueNormal:
3725         return FontWeightNormal;
3726     case CSSValue900:
3727         return FontWeight900;
3728     case CSSValue800:
3729         return FontWeight800;
3730     case CSSValue700:
3731         return FontWeight700;
3732     case CSSValue600:
3733         return FontWeight600;
3734     case CSSValue500:
3735         return FontWeight500;
3736     case CSSValue400:
3737         return FontWeight400;
3738     case CSSValue300:
3739         return FontWeight300;
3740     case CSSValue200:
3741         return FontWeight200;
3742     case CSSValue100:
3743         return FontWeight100;
3744     default:
3745         break;
3746     }
3747
3748     ASSERT_NOT_REACHED();
3749     return FontWeightNormal;
3750 }
3751
3752 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontItalic italic)
3753     : CSSValue(PrimitiveClass)
3754 {
3755     m_primitiveUnitType = CSS_VALUE_ID;
3756     switch (italic) {
3757     case FontItalicOff:
3758         m_value.valueID = CSSValueNormal;
3759         return;
3760     case FontItalicOn:
3761         m_value.valueID = CSSValueItalic;
3762         return;
3763     }
3764
3765     ASSERT_NOT_REACHED();
3766     m_value.valueID = CSSValueNormal;
3767 }
3768
3769 template<> inline CSSPrimitiveValue::operator FontItalic() const
3770 {
3771     ASSERT(isValueID());
3772
3773     switch (m_value.valueID) {
3774     case CSSValueOblique:
3775     // FIXME: oblique is the same as italic for the moment...
3776     case CSSValueItalic:
3777         return FontItalicOn;
3778     case CSSValueNormal:
3779         return FontItalicOff;
3780     default:
3781         break;
3782     }
3783     ASSERT_NOT_REACHED();
3784     return FontItalicOff;
3785 }
3786
3787 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontSmallCaps smallCaps)
3788     : CSSValue(PrimitiveClass)
3789 {
3790     m_primitiveUnitType = CSS_VALUE_ID;
3791     switch (smallCaps) {
3792     case FontSmallCapsOff:
3793         m_value.valueID = CSSValueNormal;
3794         return;
3795     case FontSmallCapsOn:
3796         m_value.valueID = CSSValueSmallCaps;
3797         return;
3798     }
3799
3800     ASSERT_NOT_REACHED();
3801     m_value.valueID = CSSValueNormal;
3802 }
3803
3804 template<> inline CSSPrimitiveValue::operator FontSmallCaps() const
3805 {
3806     ASSERT(isValueID());
3807
3808     switch (m_value.valueID) {
3809     case CSSValueSmallCaps:
3810         return FontSmallCapsOn;
3811     case CSSValueNormal:
3812         return FontSmallCapsOff;
3813     default:
3814         break;
3815     }
3816     ASSERT_NOT_REACHED();
3817     return FontSmallCapsOff;
3818 }
3819
3820 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextRenderingMode e)
3821     : CSSValue(PrimitiveClass)
3822 {
3823     m_primitiveUnitType = CSS_VALUE_ID;
3824     switch (e) {
3825     case AutoTextRendering:
3826         m_value.valueID = CSSValueAuto;
3827         break;
3828     case OptimizeSpeed:
3829         m_value.valueID = CSSValueOptimizespeed;
3830         break;
3831     case OptimizeLegibility:
3832         m_value.valueID = CSSValueOptimizelegibility;
3833         break;
3834     case GeometricPrecision:
3835         m_value.valueID = CSSValueGeometricprecision;
3836         break;
3837     }
3838 }
3839
3840 template<> inline CSSPrimitiveValue::operator TextRenderingMode() const
3841 {
3842     ASSERT(isValueID());
3843
3844     switch (m_value.valueID) {
3845     case CSSValueAuto:
3846         return AutoTextRendering;
3847     case CSSValueOptimizespeed:
3848         return OptimizeSpeed;
3849     case CSSValueOptimizelegibility:
3850         return OptimizeLegibility;
3851     case CSSValueGeometricprecision:
3852         return GeometricPrecision;
3853     default:
3854         break;
3855     }
3856
3857     ASSERT_NOT_REACHED();
3858     return AutoTextRendering;
3859 }
3860
3861 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(Hyphens hyphens)
3862     : CSSValue(PrimitiveClass)
3863 {
3864     m_primitiveUnitType = CSS_VALUE_ID;
3865     switch (hyphens) {
3866     case HyphensNone:
3867         m_value.valueID = CSSValueNone;
3868         break;
3869     case HyphensManual:
3870         m_value.valueID = CSSValueManual;
3871         break;
3872     case HyphensAuto:
3873         m_value.valueID = CSSValueAuto;
3874         break;
3875     }
3876 }
3877
3878 template<> inline CSSPrimitiveValue::operator Hyphens() const
3879 {
3880     ASSERT(isValueID());
3881
3882     switch (m_value.valueID) {
3883     case CSSValueNone:
3884         return HyphensNone;
3885     case CSSValueManual:
3886         return HyphensManual;
3887     case CSSValueAuto:
3888         return HyphensAuto;
3889     default:
3890         break;
3891     }
3892
3893     ASSERT_NOT_REACHED();
3894     return HyphensAuto;
3895 }
3896
3897 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineSnap gridSnap)
3898     : CSSValue(PrimitiveClass)
3899 {
3900     m_primitiveUnitType = CSS_VALUE_ID;
3901     switch (gridSnap) {
3902     case LineSnapNone:
3903         m_value.valueID = CSSValueNone;
3904         break;
3905     case LineSnapBaseline:
3906         m_value.valueID = CSSValueBaseline;
3907         break;
3908     case LineSnapContain:
3909         m_value.valueID = CSSValueContain;
3910         break;
3911     }
3912 }
3913
3914 template<> inline CSSPrimitiveValue::operator LineSnap() const
3915 {
3916     ASSERT(isValueID());
3917
3918     switch (m_value.valueID) {
3919     case CSSValueNone:
3920         return LineSnapNone;
3921     case CSSValueBaseline:
3922         return LineSnapBaseline;
3923     case CSSValueContain:
3924         return LineSnapContain;
3925     default:
3926         break;
3927     }
3928
3929     ASSERT_NOT_REACHED();
3930     return LineSnapNone;
3931 }
3932
3933 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineAlign lineAlign)
3934     : CSSValue(PrimitiveClass)
3935 {
3936     m_primitiveUnitType = CSS_VALUE_ID;
3937     switch (lineAlign) {
3938     case LineAlignNone:
3939         m_value.valueID = CSSValueNone;
3940         break;
3941     case LineAlignEdges:
3942         m_value.valueID = CSSValueEdges;
3943         break;
3944     }
3945 }
3946
3947 template<> inline CSSPrimitiveValue::operator LineAlign() const
3948 {
3949     ASSERT(isValueID());
3950
3951     switch (m_value.valueID) {
3952     case CSSValueNone:
3953         return LineAlignNone;
3954     case CSSValueEdges:
3955         return LineAlignEdges;
3956     default:
3957         break;
3958     }
3959
3960     ASSERT_NOT_REACHED();
3961     return LineAlignNone;
3962 }
3963
3964 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ESpeak e)
3965     : CSSValue(PrimitiveClass)
3966 {
3967     m_primitiveUnitType = CSS_VALUE_ID;
3968     switch (e) {
3969     case SpeakNone:
3970         m_value.valueID = CSSValueNone;
3971         break;
3972     case SpeakNormal:
3973         m_value.valueID = CSSValueNormal;
3974         break;
3975     case SpeakSpellOut:
3976         m_value.valueID = CSSValueSpellOut;
3977         break;
3978     case SpeakDigits:
3979         m_value.valueID = CSSValueDigits;
3980         break;
3981     case SpeakLiteralPunctuation:
3982         m_value.valueID = CSSValueLiteralPunctuation;
3983         break;
3984     case SpeakNoPunctuation:
3985         m_value.valueID = CSSValueNoPunctuation;
3986         break;
3987     }
3988 }
3989
3990 template<> inline CSSPrimitiveValue::operator Order() const
3991 {
3992     ASSERT(isValueID());
3993
3994     switch (m_value.valueID) {
3995     case CSSValueLogical:
3996         return LogicalOrder;
3997     case CSSValueVisual:
3998         return VisualOrder;
3999     default:
4000         break;
4001     }
4002
4003     ASSERT_NOT_REACHED();
4004     return LogicalOrder;
4005 }
4006
4007 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(Order e)
4008     : CSSValue(PrimitiveClass)
4009 {
4010     m_primitiveUnitType = CSS_VALUE_ID;
4011     switch (e) {
4012     case LogicalOrder:
4013         m_value.valueID = CSSValueLogical;
4014         break;
4015     case VisualOrder:
4016         m_value.valueID = CSSValueVisual;
4017         break;
4018     }
4019 }
4020
4021 template<> inline CSSPrimitiveValue::operator ESpeak() const
4022 {
4023     ASSERT(isValueID());
4024
4025     switch (m_value.valueID) {
4026     case CSSValueNone:
4027         return SpeakNone;
4028     case CSSValueNormal:
4029         return SpeakNormal;
4030     case CSSValueSpellOut:
4031         return SpeakSpellOut;
4032     case CSSValueDigits:
4033         return SpeakDigits;
4034     case CSSValueLiteralPunctuation:
4035         return SpeakLiteralPunctuation;
4036     case CSSValueNoPunctuation:
4037         return SpeakNoPunctuation;
4038     default:
4039         break;
4040     }
4041
4042     ASSERT_NOT_REACHED();
4043     return SpeakNormal;
4044 }
4045
4046 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(BlendMode blendMode)
4047     : CSSValue(PrimitiveClass)
4048 {
4049     m_primitiveUnitType = CSS_VALUE_ID;
4050     switch (blendMode) {
4051     case BlendModeNormal:
4052         m_value.valueID = CSSValueNormal;
4053         break;
4054     case BlendModeMultiply:
4055         m_value.valueID = CSSValueMultiply;
4056         break;
4057     case BlendModeScreen:
4058         m_value.valueID = CSSValueScreen;
4059         break;
4060     case BlendModeOverlay:
4061         m_value.valueID = CSSValueOverlay;
4062         break;
4063     case BlendModeDarken:
4064         m_value.valueID = CSSValueDarken;
4065         break;
4066     case BlendModeLighten:
4067         m_value.valueID = CSSValueLighten;
4068         break;
4069     case BlendModeColorDodge:
4070         m_value.valueID = CSSValueColorDodge;
4071         break;
4072     case BlendModeColorBurn:
4073         m_value.valueID = CSSValueColorBurn;
4074         break;
4075     case BlendModeHardLight:
4076         m_value.valueID = CSSValueHardLight;
4077         break;
4078     case BlendModeSoftLight:
4079         m_value.valueID = CSSValueSoftLight;
4080         break;
4081     case BlendModeDifference:
4082         m_value.valueID = CSSValueDifference;
4083         break;
4084     case BlendModeExclusion:
4085         m_value.valueID = CSSValueExclusion;
4086         break;
4087     case BlendModeHue:
4088         m_value.valueID = CSSValueHue;
4089         break;
4090     case BlendModeSaturation:
4091         m_value.valueID = CSSValueSaturation;
4092         break;
4093     case BlendModeColor:
4094         m_value.valueID = CSSValueColor;
4095         break;
4096     case BlendModeLuminosity:
4097         m_value.valueID = CSSValueLuminosity;
4098         break;
4099     case BlendModePlusDarker:
4100         m_value.valueID = CSSValuePlusDarker;
4101         break;
4102     case BlendModePlusLighter:
4103         m_value.valueID = CSSValuePlusLighter;
4104         break;
4105     }
4106 }
4107
4108 template<> inline CSSPrimitiveValue::operator BlendMode() const
4109 {
4110     ASSERT(isValueID());
4111
4112     switch (m_value.valueID) {
4113     case CSSValueNormal:
4114         return BlendModeNormal;
4115     case CSSValueMultiply:
4116         return BlendModeMultiply;
4117     case CSSValueScreen:
4118         return BlendModeScreen;
4119     case CSSValueOverlay:
4120         return BlendModeOverlay;
4121     case CSSValueDarken:
4122         return BlendModeDarken;
4123     case CSSValueLighten:
4124         return BlendModeLighten;
4125     case CSSValueColorDodge:
4126         return BlendModeColorDodge;
4127     case CSSValueColorBurn:
4128         return BlendModeColorBurn;
4129     case CSSValueHardLight:
4130         return BlendModeHardLight;
4131     case CSSValueSoftLight:
4132         return BlendModeSoftLight;
4133     case CSSValueDifference:
4134         return BlendModeDifference;
4135     case CSSValueExclusion:
4136         return BlendModeExclusion;
4137     case CSSValueHue:
4138         return BlendModeHue;
4139     case CSSValueSaturation:
4140         return BlendModeSaturation;
4141     case CSSValueColor:
4142         return BlendModeColor;
4143     case CSSValueLuminosity:
4144         return BlendModeLuminosity;
4145     case CSSValuePlusDarker:
4146         return BlendModePlusDarker;
4147     case CSSValuePlusLighter:
4148         return BlendModePlusLighter;
4149     default:
4150         break;
4151     }
4152
4153     ASSERT_NOT_REACHED();
4154     return BlendModeNormal;
4155 }
4156
4157 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(Isolation isolation)
4158     : CSSValue(PrimitiveClass)
4159 {
4160     m_primitiveUnitType = CSS_VALUE_ID;
4161     switch (isolation) {
4162     case IsolationAuto:
4163         m_value.valueID = CSSValueAuto;
4164         break;
4165     case IsolationIsolate:
4166         m_value.valueID = CSSValueIsolate;
4167         break;
4168     default:
4169         ASSERT_NOT_REACHED();
4170     }
4171 }
4172
4173 template<> inline CSSPrimitiveValue::operator Isolation() const
4174 {
4175     ASSERT(isValueID());
4176     switch (m_value.valueID) {
4177     case CSSValueAuto:
4178         return IsolationAuto;
4179     case CSSValueIsolate:
4180         return IsolationIsolate;
4181     default:
4182         break;
4183     }
4184
4185     ASSERT_NOT_REACHED();
4186     return IsolationAuto;
4187 }
4188
4189 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineCap e)
4190     : CSSValue(PrimitiveClass)
4191 {
4192     m_primitiveUnitType = CSS_VALUE_ID;
4193     switch (e) {
4194     case ButtCap:
4195         m_value.valueID = CSSValueButt;
4196         break;
4197     case RoundCap:
4198         m_value.valueID = CSSValueRound;
4199         break;
4200     case SquareCap:
4201         m_value.valueID = CSSValueSquare;
4202         break;
4203     }
4204 }
4205
4206 template<> inline CSSPrimitiveValue::operator LineCap() const
4207 {
4208     ASSERT(isValueID());
4209
4210     switch (m_value.valueID) {
4211     case CSSValueButt:
4212         return ButtCap;
4213     case CSSValueRound:
4214         return RoundCap;
4215     case CSSValueSquare:
4216         return SquareCap;
4217     default:
4218         break;
4219     }
4220
4221     ASSERT_NOT_REACHED();
4222     return ButtCap;
4223 }
4224
4225 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineJoin e)
4226     : CSSValue(PrimitiveClass)
4227 {
4228     m_primitiveUnitType = CSS_VALUE_ID;
4229     switch (e) {
4230     case MiterJoin: