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