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