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