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