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