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