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