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