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