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