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