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