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