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