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