Implement the updated port/area-based Scroll Snap Module Level 1 Spec
[WebKit-https.git] / Source / WebCore / css / CSSPrimitiveValueMappings.h
1 /*
2  * Copyright (C) 2007 Alexey Proskuryakov <ap@nypop.com>.
3  * Copyright (C) 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
4  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
5  * Copyright (C) 2009 Jeff Schiller <codedread@gmail.com>
6  * Copyright (C) Research In Motion Limited 2010. All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  *
12  * 1. Redistributions of source code must retain the above copyright
13  *    notice, this list of conditions and the following disclaimer.
14  * 2. Redistributions in binary form must reproduce the above copyright
15  *    notice, this list of conditions and the following disclaimer in the
16  *    documentation and/or other materials provided with the distribution.
17  *
18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
19  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
23  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28  */
29
30 #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 CursorCross:
1165         m_value.valueID = CSSValueCrosshair;
1166         break;
1167     case CursorDefault:
1168         m_value.valueID = CSSValueDefault;
1169         break;
1170     case CursorPointer:
1171         m_value.valueID = CSSValuePointer;
1172         break;
1173     case CursorMove:
1174         m_value.valueID = CSSValueMove;
1175         break;
1176     case CursorCell:
1177         m_value.valueID = CSSValueCell;
1178         break;
1179     case CursorVerticalText:
1180         m_value.valueID = CSSValueVerticalText;
1181         break;
1182     case CursorContextMenu:
1183         m_value.valueID = CSSValueContextMenu;
1184         break;
1185     case CursorAlias:
1186         m_value.valueID = CSSValueAlias;
1187         break;
1188     case CursorCopy:
1189         m_value.valueID = CSSValueCopy;
1190         break;
1191     case CursorNone:
1192         m_value.valueID = CSSValueNone;
1193         break;
1194     case CursorProgress:
1195         m_value.valueID = CSSValueProgress;
1196         break;
1197     case CursorNoDrop:
1198         m_value.valueID = CSSValueNoDrop;
1199         break;
1200     case CursorNotAllowed:
1201         m_value.valueID = CSSValueNotAllowed;
1202         break;
1203     case CursorZoomIn:
1204         m_value.valueID = CSSValueZoomIn;
1205         break;
1206     case CursorZoomOut:
1207         m_value.valueID = CSSValueZoomOut;
1208         break;
1209     case CursorEResize:
1210         m_value.valueID = CSSValueEResize;
1211         break;
1212     case CursorNeResize:
1213         m_value.valueID = CSSValueNeResize;
1214         break;
1215     case CursorNwResize:
1216         m_value.valueID = CSSValueNwResize;
1217         break;
1218     case CursorNResize:
1219         m_value.valueID = CSSValueNResize;
1220         break;
1221     case CursorSeResize:
1222         m_value.valueID = CSSValueSeResize;
1223         break;
1224     case CursorSwResize:
1225         m_value.valueID = CSSValueSwResize;
1226         break;
1227     case CursorSResize:
1228         m_value.valueID = CSSValueSResize;
1229         break;
1230     case CursorWResize:
1231         m_value.valueID = CSSValueWResize;
1232         break;
1233     case CursorEwResize:
1234         m_value.valueID = CSSValueEwResize;
1235         break;
1236     case CursorNsResize:
1237         m_value.valueID = CSSValueNsResize;
1238         break;
1239     case CursorNeswResize:
1240         m_value.valueID = CSSValueNeswResize;
1241         break;
1242     case CursorNwseResize:
1243         m_value.valueID = CSSValueNwseResize;
1244         break;
1245     case CursorColResize:
1246         m_value.valueID = CSSValueColResize;
1247         break;
1248     case CursorRowResize:
1249         m_value.valueID = CSSValueRowResize;
1250         break;
1251     case CursorText:
1252         m_value.valueID = CSSValueText;
1253         break;
1254     case CursorWait:
1255         m_value.valueID = CSSValueWait;
1256         break;
1257     case CursorHelp:
1258         m_value.valueID = CSSValueHelp;
1259         break;
1260     case CursorAllScroll:
1261         m_value.valueID = CSSValueAllScroll;
1262         break;
1263     case CursorWebkitGrab:
1264         m_value.valueID = CSSValueWebkitGrab;
1265         break;
1266     case CursorWebkitGrabbing:
1267         m_value.valueID = CSSValueWebkitGrabbing;
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 CSSValueWebkitZoomIn:
1279         return CursorZoomIn;
1280     case CSSValueWebkitZoomOut:
1281         return CursorZoomOut;
1282     case CSSValueNone:
1283         return CursorNone;
1284     default:
1285         return static_cast<ECursor>(m_value.valueID - CSSValueAuto);
1286     }
1287 }
1288
1289 #if ENABLE(CURSOR_VISIBILITY)
1290 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(CursorVisibility e)
1291     : CSSValue(PrimitiveClass)
1292 {
1293     m_primitiveUnitType = CSS_VALUE_ID;
1294     switch (e) {
1295     case CursorVisibilityAuto:
1296         m_value.valueID = CSSValueAuto;
1297         break;
1298     case CursorVisibilityAutoHide:
1299         m_value.valueID = CSSValueAutoHide;
1300         break;
1301     }
1302 }
1303
1304 template<> inline CSSPrimitiveValue::operator CursorVisibility() const
1305 {
1306     ASSERT(isValueID());
1307
1308     if (m_value.valueID == CSSValueAuto)
1309         return CursorVisibilityAuto;
1310     if (m_value.valueID == CSSValueAutoHide)
1311         return CursorVisibilityAutoHide;
1312
1313     ASSERT_NOT_REACHED();
1314     return CursorVisibilityAuto;
1315 }
1316 #endif
1317
1318 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EDisplay e)
1319     : CSSValue(PrimitiveClass)
1320 {
1321     m_primitiveUnitType = CSS_VALUE_ID;
1322     switch (e) {
1323     case INLINE:
1324         m_value.valueID = CSSValueInline;
1325         break;
1326     case BLOCK:
1327         m_value.valueID = CSSValueBlock;
1328         break;
1329     case LIST_ITEM:
1330         m_value.valueID = CSSValueListItem;
1331         break;
1332     case COMPACT:
1333         m_value.valueID = CSSValueCompact;
1334         break;
1335     case INLINE_BLOCK:
1336         m_value.valueID = CSSValueInlineBlock;
1337         break;
1338     case TABLE:
1339         m_value.valueID = CSSValueTable;
1340         break;
1341     case INLINE_TABLE:
1342         m_value.valueID = CSSValueInlineTable;
1343         break;
1344     case TABLE_ROW_GROUP:
1345         m_value.valueID = CSSValueTableRowGroup;
1346         break;
1347     case TABLE_HEADER_GROUP:
1348         m_value.valueID = CSSValueTableHeaderGroup;
1349         break;
1350     case TABLE_FOOTER_GROUP:
1351         m_value.valueID = CSSValueTableFooterGroup;
1352         break;
1353     case TABLE_ROW:
1354         m_value.valueID = CSSValueTableRow;
1355         break;
1356     case TABLE_COLUMN_GROUP:
1357         m_value.valueID = CSSValueTableColumnGroup;
1358         break;
1359     case TABLE_COLUMN:
1360         m_value.valueID = CSSValueTableColumn;
1361         break;
1362     case TABLE_CELL:
1363         m_value.valueID = CSSValueTableCell;
1364         break;
1365     case TABLE_CAPTION:
1366         m_value.valueID = CSSValueTableCaption;
1367         break;
1368     case BOX:
1369         m_value.valueID = CSSValueWebkitBox;
1370         break;
1371     case INLINE_BOX:
1372         m_value.valueID = CSSValueWebkitInlineBox;
1373         break;
1374     case FLEX:
1375     case WEBKIT_FLEX:
1376         m_value.valueID = CSSValueFlex;
1377         break;
1378     case INLINE_FLEX:
1379     case WEBKIT_INLINE_FLEX:
1380         m_value.valueID = CSSValueInlineFlex;
1381         break;
1382 #if ENABLE(CSS_GRID_LAYOUT)
1383     case GRID:
1384         m_value.valueID = CSSValueGrid;
1385         break;
1386     case INLINE_GRID:
1387         m_value.valueID = CSSValueInlineGrid;
1388         break;
1389 #endif
1390     case NONE:
1391         m_value.valueID = CSSValueNone;
1392         break;
1393     case CONTENTS:
1394         m_value.valueID = CSSValueContents;
1395         break;
1396     }
1397 }
1398
1399 template<> inline CSSPrimitiveValue::operator EDisplay() const
1400 {
1401     ASSERT(isValueID());
1402
1403     if (m_value.valueID == CSSValueNone)
1404         return NONE;
1405
1406     EDisplay display = static_cast<EDisplay>(m_value.valueID - CSSValueInline);
1407     ASSERT(display >= INLINE && display <= NONE);
1408     if (display == WEBKIT_FLEX)
1409         return FLEX;
1410     if (display == WEBKIT_INLINE_FLEX)
1411         return INLINE_FLEX;
1412     return display;
1413 }
1414
1415 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EEmptyCell e)
1416     : CSSValue(PrimitiveClass)
1417 {
1418     m_primitiveUnitType = CSS_VALUE_ID;
1419     switch (e) {
1420     case SHOW:
1421         m_value.valueID = CSSValueShow;
1422         break;
1423     case HIDE:
1424         m_value.valueID = CSSValueHide;
1425         break;
1426     }
1427 }
1428
1429 template<> inline CSSPrimitiveValue::operator EEmptyCell() const
1430 {
1431     ASSERT(isValueID());
1432
1433     switch (m_value.valueID) {
1434     case CSSValueShow:
1435         return SHOW;
1436     case CSSValueHide:
1437         return HIDE;
1438     default:
1439         break;
1440     }
1441
1442     ASSERT_NOT_REACHED();
1443     return SHOW;
1444 }
1445
1446 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFlexDirection e)
1447     : CSSValue(PrimitiveClass)
1448 {
1449     m_primitiveUnitType = CSS_VALUE_ID;
1450     switch (e) {
1451     case FlowRow:
1452         m_value.valueID = CSSValueRow;
1453         break;
1454     case FlowRowReverse:
1455         m_value.valueID = CSSValueRowReverse;
1456         break;
1457     case FlowColumn:
1458         m_value.valueID = CSSValueColumn;
1459         break;
1460     case FlowColumnReverse:
1461         m_value.valueID = CSSValueColumnReverse;
1462         break;
1463     }
1464 }
1465
1466 template<> inline CSSPrimitiveValue::operator EFlexDirection() const
1467 {
1468     ASSERT(isValueID());
1469
1470     switch (m_value.valueID) {
1471     case CSSValueRow:
1472         return FlowRow;
1473     case CSSValueRowReverse:
1474         return FlowRowReverse;
1475     case CSSValueColumn:
1476         return FlowColumn;
1477     case CSSValueColumnReverse:
1478         return FlowColumnReverse;
1479     default:
1480         break;
1481     }
1482
1483     ASSERT_NOT_REACHED();
1484     return FlowRow;
1485 }
1486
1487 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EAlignContent e)
1488     : CSSValue(PrimitiveClass)
1489 {
1490     m_primitiveUnitType = CSS_VALUE_ID;
1491     switch (e) {
1492     case AlignContentFlexStart:
1493         m_value.valueID = CSSValueFlexStart;
1494         break;
1495     case AlignContentFlexEnd:
1496         m_value.valueID = CSSValueFlexEnd;
1497         break;
1498     case AlignContentCenter:
1499         m_value.valueID = CSSValueCenter;
1500         break;
1501     case AlignContentSpaceBetween:
1502         m_value.valueID = CSSValueSpaceBetween;
1503         break;
1504     case AlignContentSpaceAround:
1505         m_value.valueID = CSSValueSpaceAround;
1506         break;
1507     case AlignContentStretch:
1508         m_value.valueID = CSSValueStretch;
1509         break;
1510     }
1511 }
1512
1513 template<> inline CSSPrimitiveValue::operator EAlignContent() const
1514 {
1515     ASSERT(isValueID());
1516
1517     switch (m_value.valueID) {
1518     case CSSValueFlexStart:
1519         return AlignContentFlexStart;
1520     case CSSValueFlexEnd:
1521         return AlignContentFlexEnd;
1522     case CSSValueCenter:
1523         return AlignContentCenter;
1524     case CSSValueSpaceBetween:
1525         return AlignContentSpaceBetween;
1526     case CSSValueSpaceAround:
1527         return AlignContentSpaceAround;
1528     case CSSValueStretch:
1529         return AlignContentStretch;
1530     default:
1531         break;
1532     }
1533
1534     ASSERT_NOT_REACHED();
1535     return AlignContentStretch;
1536 }
1537
1538 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFlexWrap e)
1539     : CSSValue(PrimitiveClass)
1540 {
1541     m_primitiveUnitType = CSS_VALUE_ID;
1542     switch (e) {
1543     case FlexNoWrap:
1544         m_value.valueID = CSSValueNowrap;
1545         break;
1546     case FlexWrap:
1547         m_value.valueID = CSSValueWrap;
1548         break;
1549     case FlexWrapReverse:
1550         m_value.valueID = CSSValueWrapReverse;
1551         break;
1552     }
1553 }
1554
1555 template<> inline CSSPrimitiveValue::operator EFlexWrap() const
1556 {
1557     ASSERT(isValueID());
1558
1559     switch (m_value.valueID) {
1560     case CSSValueNowrap:
1561         return FlexNoWrap;
1562     case CSSValueWrap:
1563         return FlexWrap;
1564     case CSSValueWrapReverse:
1565         return FlexWrapReverse;
1566     default:
1567         break;
1568     }
1569
1570     ASSERT_NOT_REACHED();
1571     return FlexNoWrap;
1572 }
1573
1574 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFloat e)
1575     : CSSValue(PrimitiveClass)
1576 {
1577     m_primitiveUnitType = CSS_VALUE_ID;
1578     switch (e) {
1579     case NoFloat:
1580         m_value.valueID = CSSValueNone;
1581         break;
1582     case LeftFloat:
1583         m_value.valueID = CSSValueLeft;
1584         break;
1585     case RightFloat:
1586         m_value.valueID = CSSValueRight;
1587         break;
1588     }
1589 }
1590
1591 template<> inline CSSPrimitiveValue::operator EFloat() const
1592 {
1593     ASSERT(isValueID());
1594
1595     switch (m_value.valueID) {
1596     case CSSValueLeft:
1597         return LeftFloat;
1598     case CSSValueRight:
1599         return RightFloat;
1600     case CSSValueNone:
1601     case CSSValueCenter: // Non-standard CSS value.
1602         return NoFloat;
1603     default:
1604         break;
1605     }
1606
1607     ASSERT_NOT_REACHED();
1608     return NoFloat;
1609 }
1610
1611 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineBreak e)
1612     : CSSValue(PrimitiveClass)
1613 {
1614     m_primitiveUnitType = CSS_VALUE_ID;
1615     switch (e) {
1616     case LineBreakAuto:
1617         m_value.valueID = CSSValueAuto;
1618         break;
1619     case LineBreakLoose:
1620         m_value.valueID = CSSValueLoose;
1621         break;
1622     case LineBreakNormal:
1623         m_value.valueID = CSSValueNormal;
1624         break;
1625     case LineBreakStrict:
1626         m_value.valueID = CSSValueStrict;
1627         break;
1628     case LineBreakAfterWhiteSpace:
1629         m_value.valueID = CSSValueAfterWhiteSpace;
1630         break;
1631     }
1632 }
1633
1634 template<> inline CSSPrimitiveValue::operator HangingPunctuation() const
1635 {
1636     ASSERT(isValueID());
1637     
1638     switch (m_value.valueID) {
1639     case CSSValueNone:
1640         return NoHangingPunctuation;
1641     case CSSValueFirst:
1642         return FirstHangingPunctuation;
1643     case CSSValueLast:
1644         return LastHangingPunctuation;
1645     case CSSValueAllowEnd:
1646         return AllowEndHangingPunctuation;
1647     case CSSValueForceEnd:
1648         return ForceEndHangingPunctuation;
1649     default:
1650         break;
1651     }
1652     
1653     ASSERT_NOT_REACHED();
1654     return NoHangingPunctuation;
1655 }
1656
1657 template<> inline CSSPrimitiveValue::operator LineBreak() const
1658 {
1659     ASSERT(isValueID());
1660
1661     switch (m_value.valueID) {
1662     case CSSValueAuto:
1663         return LineBreakAuto;
1664     case CSSValueLoose:
1665         return LineBreakLoose;
1666     case CSSValueNormal:
1667         return LineBreakNormal;
1668     case CSSValueStrict:
1669         return LineBreakStrict;
1670     case CSSValueAfterWhiteSpace:
1671         return LineBreakAfterWhiteSpace;
1672     default:
1673         break;
1674     }
1675
1676     ASSERT_NOT_REACHED();
1677     return LineBreakAuto;
1678 }
1679
1680 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EListStylePosition e)
1681     : CSSValue(PrimitiveClass)
1682 {
1683     m_primitiveUnitType = CSS_VALUE_ID;
1684     switch (e) {
1685     case OUTSIDE:
1686         m_value.valueID = CSSValueOutside;
1687         break;
1688     case INSIDE:
1689         m_value.valueID = CSSValueInside;
1690         break;
1691     }
1692 }
1693
1694 template<> inline CSSPrimitiveValue::operator EListStylePosition() const
1695 {
1696     ASSERT(isValueID());
1697
1698     switch (m_value.valueID) {
1699     case CSSValueOutside:
1700         return OUTSIDE;
1701     case CSSValueInside:
1702         return INSIDE;
1703     default:
1704         break;
1705     }
1706
1707     ASSERT_NOT_REACHED();
1708     return OUTSIDE;
1709 }
1710
1711 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EListStyleType e)
1712     : CSSValue(PrimitiveClass)
1713 {
1714     m_primitiveUnitType = CSS_VALUE_ID;
1715     switch (e) {
1716     case Afar:
1717         m_value.valueID = CSSValueAfar;
1718         break;
1719     case Amharic:
1720         m_value.valueID = CSSValueAmharic;
1721         break;
1722     case AmharicAbegede:
1723         m_value.valueID = CSSValueAmharicAbegede;
1724         break;
1725     case ArabicIndic:
1726         m_value.valueID = CSSValueArabicIndic;
1727         break;
1728     case Armenian:
1729         m_value.valueID = CSSValueArmenian;
1730         break;
1731     case Asterisks:
1732         m_value.valueID = CSSValueAsterisks;
1733         break;
1734     case BinaryListStyle:
1735         m_value.valueID = CSSValueBinary;
1736         break;
1737     case Bengali:
1738         m_value.valueID = CSSValueBengali;
1739         break;
1740     case Cambodian:
1741         m_value.valueID = CSSValueCambodian;
1742         break;
1743     case Circle:
1744         m_value.valueID = CSSValueCircle;
1745         break;
1746     case CjkEarthlyBranch:
1747         m_value.valueID = CSSValueCjkEarthlyBranch;
1748         break;
1749     case CjkHeavenlyStem:
1750         m_value.valueID = CSSValueCjkHeavenlyStem;
1751         break;
1752     case CJKIdeographic:
1753         m_value.valueID = CSSValueCjkIdeographic;
1754         break;
1755     case DecimalLeadingZero:
1756         m_value.valueID = CSSValueDecimalLeadingZero;
1757         break;
1758     case DecimalListStyle:
1759         m_value.valueID = CSSValueDecimal;
1760         break;
1761     case Devanagari:
1762         m_value.valueID = CSSValueDevanagari;
1763         break;
1764     case Disc:
1765         m_value.valueID = CSSValueDisc;
1766         break;
1767     case Ethiopic:
1768         m_value.valueID = CSSValueEthiopic;
1769         break;
1770     case EthiopicAbegede:
1771         m_value.valueID = CSSValueEthiopicAbegede;
1772         break;
1773     case EthiopicAbegedeAmEt:
1774         m_value.valueID = CSSValueEthiopicAbegedeAmEt;
1775         break;
1776     case EthiopicAbegedeGez:
1777         m_value.valueID = CSSValueEthiopicAbegedeGez;
1778         break;
1779     case EthiopicAbegedeTiEr:
1780         m_value.valueID = CSSValueEthiopicAbegedeTiEr;
1781         break;
1782     case EthiopicAbegedeTiEt:
1783         m_value.valueID = CSSValueEthiopicAbegedeTiEt;
1784         break;
1785     case EthiopicHalehameAaEr:
1786         m_value.valueID = CSSValueEthiopicHalehameAaEr;
1787         break;
1788     case EthiopicHalehameAaEt:
1789         m_value.valueID = CSSValueEthiopicHalehameAaEt;
1790         break;
1791     case EthiopicHalehameAmEt:
1792         m_value.valueID = CSSValueEthiopicHalehameAmEt;
1793         break;
1794     case EthiopicHalehameGez:
1795         m_value.valueID = CSSValueEthiopicHalehameGez;
1796         break;
1797     case EthiopicHalehameOmEt:
1798         m_value.valueID = CSSValueEthiopicHalehameOmEt;
1799         break;
1800     case EthiopicHalehameSidEt:
1801         m_value.valueID = CSSValueEthiopicHalehameSidEt;
1802         break;
1803     case EthiopicHalehameSoEt:
1804         m_value.valueID = CSSValueEthiopicHalehameSoEt;
1805         break;
1806     case EthiopicHalehameTiEr:
1807         m_value.valueID = CSSValueEthiopicHalehameTiEr;
1808         break;
1809     case EthiopicHalehameTiEt:
1810         m_value.valueID = CSSValueEthiopicHalehameTiEt;
1811         break;
1812     case EthiopicHalehameTig:
1813         m_value.valueID = CSSValueEthiopicHalehameTig;
1814         break;
1815     case Footnotes:
1816         m_value.valueID = CSSValueFootnotes;
1817         break;
1818     case Georgian:
1819         m_value.valueID = CSSValueGeorgian;
1820         break;
1821     case Gujarati:
1822         m_value.valueID = CSSValueGujarati;
1823         break;
1824     case Gurmukhi:
1825         m_value.valueID = CSSValueGurmukhi;
1826         break;
1827     case Hangul:
1828         m_value.valueID = CSSValueHangul;
1829         break;
1830     case HangulConsonant:
1831         m_value.valueID = CSSValueHangulConsonant;
1832         break;
1833     case Hebrew:
1834         m_value.valueID = CSSValueHebrew;
1835         break;
1836     case Hiragana:
1837         m_value.valueID = CSSValueHiragana;
1838         break;
1839     case HiraganaIroha:
1840         m_value.valueID = CSSValueHiraganaIroha;
1841         break;
1842     case Kannada:
1843         m_value.valueID = CSSValueKannada;
1844         break;
1845     case Katakana:
1846         m_value.valueID = CSSValueKatakana;
1847         break;
1848     case KatakanaIroha:
1849         m_value.valueID = CSSValueKatakanaIroha;
1850         break;
1851     case Khmer:
1852         m_value.valueID = CSSValueKhmer;
1853         break;
1854     case Lao:
1855         m_value.valueID = CSSValueLao;
1856         break;
1857     case LowerAlpha:
1858         m_value.valueID = CSSValueLowerAlpha;
1859         break;
1860     case LowerArmenian:
1861         m_value.valueID = CSSValueLowerArmenian;
1862         break;
1863     case LowerGreek:
1864         m_value.valueID = CSSValueLowerGreek;
1865         break;
1866     case LowerHexadecimal:
1867         m_value.valueID = CSSValueLowerHexadecimal;
1868         break;
1869     case LowerLatin:
1870         m_value.valueID = CSSValueLowerLatin;
1871         break;
1872     case LowerNorwegian:
1873         m_value.valueID = CSSValueLowerNorwegian;
1874         break;
1875     case LowerRoman:
1876         m_value.valueID = CSSValueLowerRoman;
1877         break;
1878     case Malayalam:
1879         m_value.valueID = CSSValueMalayalam;
1880         break;
1881     case Mongolian:
1882         m_value.valueID = CSSValueMongolian;
1883         break;
1884     case Myanmar:
1885         m_value.valueID = CSSValueMyanmar;
1886         break;
1887     case NoneListStyle:
1888         m_value.valueID = CSSValueNone;
1889         break;
1890     case Octal:
1891         m_value.valueID = CSSValueOctal;
1892         break;
1893     case Oriya:
1894         m_value.valueID = CSSValueOriya;
1895         break;
1896     case Oromo:
1897         m_value.valueID = CSSValueOromo;
1898         break;
1899     case Persian:
1900         m_value.valueID = CSSValuePersian;
1901         break;
1902     case Sidama:
1903         m_value.valueID = CSSValueSidama;
1904         break;
1905     case Somali:
1906         m_value.valueID = CSSValueSomali;
1907         break;
1908     case Square:
1909         m_value.valueID = CSSValueSquare;
1910         break;
1911     case Telugu:
1912         m_value.valueID = CSSValueTelugu;
1913         break;
1914     case Thai:
1915         m_value.valueID = CSSValueThai;
1916         break;
1917     case Tibetan:
1918         m_value.valueID = CSSValueTibetan;
1919         break;
1920     case Tigre:
1921         m_value.valueID = CSSValueTigre;
1922         break;
1923     case TigrinyaEr:
1924         m_value.valueID = CSSValueTigrinyaEr;
1925         break;
1926     case TigrinyaErAbegede:
1927         m_value.valueID = CSSValueTigrinyaErAbegede;
1928         break;
1929     case TigrinyaEt:
1930         m_value.valueID = CSSValueTigrinyaEt;
1931         break;
1932     case TigrinyaEtAbegede:
1933         m_value.valueID = CSSValueTigrinyaEtAbegede;
1934         break;
1935     case UpperAlpha:
1936         m_value.valueID = CSSValueUpperAlpha;
1937         break;
1938     case UpperArmenian:
1939         m_value.valueID = CSSValueUpperArmenian;
1940         break;
1941     case UpperGreek:
1942         m_value.valueID = CSSValueUpperGreek;
1943         break;
1944     case UpperHexadecimal:
1945         m_value.valueID = CSSValueUpperHexadecimal;
1946         break;
1947     case UpperLatin:
1948         m_value.valueID = CSSValueUpperLatin;
1949         break;
1950     case UpperNorwegian:
1951         m_value.valueID = CSSValueUpperNorwegian;
1952         break;
1953     case UpperRoman:
1954         m_value.valueID = CSSValueUpperRoman;
1955         break;
1956     case Urdu:
1957         m_value.valueID = CSSValueUrdu;
1958         break;
1959     }
1960 }
1961
1962 template<> inline CSSPrimitiveValue::operator EListStyleType() const
1963 {
1964     ASSERT(isValueID());
1965
1966     switch (m_value.valueID) {
1967     case CSSValueNone:
1968         return NoneListStyle;
1969     default:
1970         return static_cast<EListStyleType>(m_value.valueID - CSSValueDisc);
1971     }
1972 }
1973
1974 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EMarginCollapse e)
1975     : CSSValue(PrimitiveClass)
1976 {
1977     m_primitiveUnitType = CSS_VALUE_ID;
1978     switch (e) {
1979     case MCOLLAPSE:
1980         m_value.valueID = CSSValueCollapse;
1981         break;
1982     case MSEPARATE:
1983         m_value.valueID = CSSValueSeparate;
1984         break;
1985     case MDISCARD:
1986         m_value.valueID = CSSValueDiscard;
1987         break;
1988     }
1989 }
1990
1991 template<> inline CSSPrimitiveValue::operator EMarginCollapse() const
1992 {
1993     ASSERT(isValueID());
1994
1995     switch (m_value.valueID) {
1996     case CSSValueCollapse:
1997         return MCOLLAPSE;
1998     case CSSValueSeparate:
1999         return MSEPARATE;
2000     case CSSValueDiscard:
2001         return MDISCARD;
2002     default:
2003         break;
2004     }
2005
2006     ASSERT_NOT_REACHED();
2007     return MCOLLAPSE;
2008 }
2009
2010 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EMarqueeBehavior e)
2011     : CSSValue(PrimitiveClass)
2012 {
2013     m_primitiveUnitType = CSS_VALUE_ID;
2014     switch (e) {
2015     case MNONE:
2016         m_value.valueID = CSSValueNone;
2017         break;
2018     case MSCROLL:
2019         m_value.valueID = CSSValueScroll;
2020         break;
2021     case MSLIDE:
2022         m_value.valueID = CSSValueSlide;
2023         break;
2024     case MALTERNATE:
2025         m_value.valueID = CSSValueAlternate;
2026         break;
2027     }
2028 }
2029
2030 template<> inline CSSPrimitiveValue::operator EMarqueeBehavior() const
2031 {
2032     ASSERT(isValueID());
2033
2034     switch (m_value.valueID) {
2035     case CSSValueNone:
2036         return MNONE;
2037     case CSSValueScroll:
2038         return MSCROLL;
2039     case CSSValueSlide:
2040         return MSLIDE;
2041     case CSSValueAlternate:
2042         return MALTERNATE;
2043     default:
2044         break;
2045     }
2046
2047     ASSERT_NOT_REACHED();
2048     return MNONE;
2049 }
2050
2051 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(RegionFragment e)
2052     : CSSValue(PrimitiveClass)
2053 {
2054     m_primitiveUnitType = CSS_VALUE_ID;
2055     switch (e) {
2056     case AutoRegionFragment:
2057         m_value.valueID = CSSValueAuto;
2058         break;
2059     case BreakRegionFragment:
2060         m_value.valueID = CSSValueBreak;
2061         break;
2062     }
2063 }
2064
2065 template<> inline CSSPrimitiveValue::operator RegionFragment() const
2066 {
2067     ASSERT(isValueID());
2068
2069     switch (m_value.valueID) {
2070     case CSSValueAuto:
2071         return AutoRegionFragment;
2072     case CSSValueBreak:
2073         return BreakRegionFragment;
2074     default:
2075         break;
2076     }
2077
2078     ASSERT_NOT_REACHED();
2079     return AutoRegionFragment;
2080 }
2081
2082 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EMarqueeDirection e)
2083     : CSSValue(PrimitiveClass)
2084 {
2085     m_primitiveUnitType = CSS_VALUE_ID;
2086     switch (e) {
2087     case MFORWARD:
2088         m_value.valueID = CSSValueForwards;
2089         break;
2090     case MBACKWARD:
2091         m_value.valueID = CSSValueBackwards;
2092         break;
2093     case MAUTO:
2094         m_value.valueID = CSSValueAuto;
2095         break;
2096     case MUP:
2097         m_value.valueID = CSSValueUp;
2098         break;
2099     case MDOWN:
2100         m_value.valueID = CSSValueDown;
2101         break;
2102     case MLEFT:
2103         m_value.valueID = CSSValueLeft;
2104         break;
2105     case MRIGHT:
2106         m_value.valueID = CSSValueRight;
2107         break;
2108     }
2109 }
2110
2111 template<> inline CSSPrimitiveValue::operator EMarqueeDirection() const
2112 {
2113     ASSERT(isValueID());
2114
2115     switch (m_value.valueID) {
2116     case CSSValueForwards:
2117         return MFORWARD;
2118     case CSSValueBackwards:
2119         return MBACKWARD;
2120     case CSSValueAuto:
2121         return MAUTO;
2122     case CSSValueAhead:
2123     case CSSValueUp: // We don't support vertical languages, so AHEAD just maps to UP.
2124         return MUP;
2125     case CSSValueReverse:
2126     case CSSValueDown: // REVERSE just maps to DOWN, since we don't do vertical text.
2127         return MDOWN;
2128     case CSSValueLeft:
2129         return MLEFT;
2130     case CSSValueRight:
2131         return MRIGHT;
2132     default:
2133         break;
2134     }
2135
2136     ASSERT_NOT_REACHED();
2137     return MAUTO;
2138 }
2139
2140 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ENBSPMode e)
2141     : CSSValue(PrimitiveClass)
2142 {
2143     m_primitiveUnitType = CSS_VALUE_ID;
2144     switch (e) {
2145     case NBNORMAL:
2146         m_value.valueID = CSSValueNormal;
2147         break;
2148     case SPACE:
2149         m_value.valueID = CSSValueSpace;
2150         break;
2151     }
2152 }
2153
2154 template<> inline CSSPrimitiveValue::operator ENBSPMode() const
2155 {
2156     ASSERT(isValueID());
2157
2158     switch (m_value.valueID) {
2159     case CSSValueSpace:
2160         return SPACE;
2161     case CSSValueNormal:
2162         return NBNORMAL;
2163     default:
2164         break;
2165     }
2166
2167     ASSERT_NOT_REACHED();
2168     return NBNORMAL;
2169 }
2170
2171 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EOverflow e)
2172     : CSSValue(PrimitiveClass)
2173 {
2174     m_primitiveUnitType = CSS_VALUE_ID;
2175     switch (e) {
2176     case OVISIBLE:
2177         m_value.valueID = CSSValueVisible;
2178         break;
2179     case OHIDDEN:
2180         m_value.valueID = CSSValueHidden;
2181         break;
2182     case OSCROLL:
2183         m_value.valueID = CSSValueScroll;
2184         break;
2185     case OAUTO:
2186         m_value.valueID = CSSValueAuto;
2187         break;
2188     case OOVERLAY:
2189         m_value.valueID = CSSValueOverlay;
2190         break;
2191     case OPAGEDX:
2192         m_value.valueID = CSSValueWebkitPagedX;
2193         break;
2194     case OPAGEDY:
2195         m_value.valueID = CSSValueWebkitPagedY;
2196         break;
2197     }
2198 }
2199
2200 template<> inline CSSPrimitiveValue::operator EOverflow() const
2201 {
2202     ASSERT(isValueID());
2203
2204     switch (m_value.valueID) {
2205     case CSSValueVisible:
2206         return OVISIBLE;
2207     case CSSValueHidden:
2208         return OHIDDEN;
2209     case CSSValueScroll:
2210         return OSCROLL;
2211     case CSSValueAuto:
2212         return OAUTO;
2213     case CSSValueOverlay:
2214         return OOVERLAY;
2215     case CSSValueWebkitPagedX:
2216         return OPAGEDX;
2217     case CSSValueWebkitPagedY:
2218         return OPAGEDY;
2219     default:
2220         break;
2221     }
2222
2223     ASSERT_NOT_REACHED();
2224     return OVISIBLE;
2225 }
2226
2227 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(BreakBetween e)
2228     : CSSValue(PrimitiveClass)
2229 {
2230     m_primitiveUnitType = CSS_VALUE_ID;
2231     switch (e) {
2232     case AutoBreakBetween:
2233         m_value.valueID = CSSValueAuto;
2234         break;
2235     case AvoidBreakBetween:
2236         m_value.valueID = CSSValueAvoid;
2237         break;
2238     case AvoidColumnBreakBetween:
2239         m_value.valueID = CSSValueAvoidColumn;
2240         break;
2241     case AvoidPageBreakBetween:
2242         m_value.valueID = CSSValueAvoidPage;
2243         break;
2244     case AvoidRegionBreakBetween:
2245         m_value.valueID = CSSValueAvoidRegion;
2246         break;
2247     case ColumnBreakBetween:
2248         m_value.valueID = CSSValueColumn;
2249         break;
2250     case PageBreakBetween:
2251         m_value.valueID = CSSValuePage;
2252         break;
2253     case RegionBreakBetween:
2254         m_value.valueID = CSSValueRegion;
2255         break;
2256     case LeftPageBreakBetween:
2257         m_value.valueID = CSSValueLeft;
2258         break;
2259     case RightPageBreakBetween:
2260         m_value.valueID = CSSValueRight;
2261         break;
2262     case RectoPageBreakBetween:
2263         m_value.valueID = CSSValueRecto;
2264         break;
2265     case VersoPageBreakBetween:
2266         m_value.valueID = CSSValueVerso;
2267         break;
2268     }
2269 }
2270
2271 template<> inline CSSPrimitiveValue::operator BreakBetween() const
2272 {
2273     ASSERT(isValueID());
2274
2275     switch (m_value.valueID) {
2276     case CSSValueAuto:
2277         return AutoBreakBetween;
2278     case CSSValueAvoid:
2279         return AvoidBreakBetween;
2280     case CSSValueAvoidColumn:
2281         return AvoidColumnBreakBetween;
2282     case CSSValueAvoidPage:
2283         return AvoidPageBreakBetween;
2284     case CSSValueAvoidRegion:
2285         return AvoidRegionBreakBetween;
2286     case CSSValueColumn:
2287         return ColumnBreakBetween;
2288     case CSSValuePage:
2289         return PageBreakBetween;
2290     case CSSValueRegion:
2291         return RegionBreakBetween;
2292     case CSSValueLeft:
2293         return LeftPageBreakBetween;
2294     case CSSValueRight:
2295         return RightPageBreakBetween;
2296     case CSSValueRecto:
2297         return RectoPageBreakBetween;
2298     case CSSValueVerso:
2299         return VersoPageBreakBetween;
2300     default:
2301         break;
2302     }
2303
2304     ASSERT_NOT_REACHED();
2305     return AutoBreakBetween;
2306 }
2307
2308 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(BreakInside e)
2309     : CSSValue(PrimitiveClass)
2310 {
2311     m_primitiveUnitType = CSS_VALUE_ID;
2312     switch (e) {
2313     case AutoBreakInside:
2314         m_value.valueID = CSSValueAuto;
2315         break;
2316     case AvoidBreakInside:
2317         m_value.valueID = CSSValueAvoid;
2318         break;
2319     case AvoidColumnBreakInside:
2320         m_value.valueID = CSSValueAvoidColumn;
2321         break;
2322     case AvoidPageBreakInside:
2323         m_value.valueID = CSSValueAvoidPage;
2324         break;
2325     case AvoidRegionBreakInside:
2326         m_value.valueID = CSSValueAvoidRegion;
2327         break;
2328     }
2329 }
2330
2331 template<> inline CSSPrimitiveValue::operator BreakInside() const
2332 {
2333     ASSERT(isValueID());
2334     
2335     switch (m_value.valueID) {
2336     case CSSValueAuto:
2337         return AutoBreakInside;
2338     case CSSValueAvoid:
2339         return AvoidBreakInside;
2340     case CSSValueAvoidColumn:
2341         return AvoidColumnBreakInside;
2342     case CSSValueAvoidPage:
2343         return AvoidPageBreakInside;
2344     case CSSValueAvoidRegion:
2345         return AvoidRegionBreakInside;
2346     default:
2347         break;
2348     }
2349
2350     ASSERT_NOT_REACHED();
2351     return AutoBreakInside;
2352 }
2353
2354 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EPosition e)
2355     : CSSValue(PrimitiveClass)
2356 {
2357     m_primitiveUnitType = CSS_VALUE_ID;
2358     switch (e) {
2359     case StaticPosition:
2360         m_value.valueID = CSSValueStatic;
2361         break;
2362     case RelativePosition:
2363         m_value.valueID = CSSValueRelative;
2364         break;
2365     case AbsolutePosition:
2366         m_value.valueID = CSSValueAbsolute;
2367         break;
2368     case FixedPosition:
2369         m_value.valueID = CSSValueFixed;
2370         break;
2371     case StickyPosition:
2372         m_value.valueID = CSSValueWebkitSticky;
2373         break;
2374     }
2375 }
2376
2377 template<> inline CSSPrimitiveValue::operator EPosition() const
2378 {
2379     ASSERT(isValueID());
2380
2381     switch (m_value.valueID) {
2382     case CSSValueStatic:
2383         return StaticPosition;
2384     case CSSValueRelative:
2385         return RelativePosition;
2386     case CSSValueAbsolute:
2387         return AbsolutePosition;
2388     case CSSValueFixed:
2389         return FixedPosition;
2390     case CSSValueWebkitSticky:
2391         return StickyPosition;
2392     default:
2393         break;
2394     }
2395
2396     ASSERT_NOT_REACHED();
2397     return StaticPosition;
2398 }
2399
2400 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EResize e)
2401     : CSSValue(PrimitiveClass)
2402 {
2403     m_primitiveUnitType = CSS_VALUE_ID;
2404     switch (e) {
2405     case RESIZE_BOTH:
2406         m_value.valueID = CSSValueBoth;
2407         break;
2408     case RESIZE_HORIZONTAL:
2409         m_value.valueID = CSSValueHorizontal;
2410         break;
2411     case RESIZE_VERTICAL:
2412         m_value.valueID = CSSValueVertical;
2413         break;
2414     case RESIZE_NONE:
2415         m_value.valueID = CSSValueNone;
2416         break;
2417     }
2418 }
2419
2420 template<> inline CSSPrimitiveValue::operator EResize() const
2421 {
2422     ASSERT(isValueID());
2423
2424     switch (m_value.valueID) {
2425     case CSSValueBoth:
2426         return RESIZE_BOTH;
2427     case CSSValueHorizontal:
2428         return RESIZE_HORIZONTAL;
2429     case CSSValueVertical:
2430         return RESIZE_VERTICAL;
2431     case CSSValueAuto:
2432         ASSERT_NOT_REACHED(); // Depends on settings, thus should be handled by the caller.
2433         return RESIZE_NONE;
2434     case CSSValueNone:
2435         return RESIZE_NONE;
2436     default:
2437         break;
2438     }
2439
2440     ASSERT_NOT_REACHED();
2441     return RESIZE_NONE;
2442 }
2443
2444 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETableLayout e)
2445     : CSSValue(PrimitiveClass)
2446 {
2447     m_primitiveUnitType = CSS_VALUE_ID;
2448     switch (e) {
2449     case TAUTO:
2450         m_value.valueID = CSSValueAuto;
2451         break;
2452     case TFIXED:
2453         m_value.valueID = CSSValueFixed;
2454         break;
2455     }
2456 }
2457
2458 template<> inline CSSPrimitiveValue::operator ETableLayout() const
2459 {
2460     ASSERT(isValueID());
2461
2462     switch (m_value.valueID) {
2463     case CSSValueFixed:
2464         return TFIXED;
2465     case CSSValueAuto:
2466         return TAUTO;
2467     default:
2468         break;
2469     }
2470
2471     ASSERT_NOT_REACHED();
2472     return TAUTO;
2473 }
2474
2475 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETextAlign e)
2476     : CSSValue(PrimitiveClass)
2477 {
2478     m_primitiveUnitType = CSS_VALUE_ID;
2479     switch (e) {
2480     case TASTART:
2481         m_value.valueID = CSSValueStart;
2482         break;
2483     case TAEND:
2484         m_value.valueID = CSSValueEnd;
2485         break;
2486     case LEFT:
2487         m_value.valueID = CSSValueLeft;
2488         break;
2489     case RIGHT:
2490         m_value.valueID = CSSValueRight;
2491         break;
2492     case CENTER:
2493         m_value.valueID = CSSValueCenter;
2494         break;
2495     case JUSTIFY:
2496         m_value.valueID = CSSValueJustify;
2497         break;
2498     case WEBKIT_LEFT:
2499         m_value.valueID = CSSValueWebkitLeft;
2500         break;
2501     case WEBKIT_RIGHT:
2502         m_value.valueID = CSSValueWebkitRight;
2503         break;
2504     case WEBKIT_CENTER:
2505         m_value.valueID = CSSValueWebkitCenter;
2506         break;
2507     }
2508 }
2509
2510 template<> inline CSSPrimitiveValue::operator ETextAlign() const
2511 {
2512     ASSERT(isValueID());
2513
2514     switch (m_value.valueID) {
2515     case CSSValueWebkitAuto: // Legacy -webkit-auto. Eqiuvalent to start.
2516     case CSSValueStart:
2517         return TASTART;
2518     case CSSValueEnd:
2519         return TAEND;
2520     default:
2521         return static_cast<ETextAlign>(m_value.valueID - CSSValueLeft);
2522     }
2523 }
2524
2525 #if ENABLE(CSS3_TEXT)
2526 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextAlignLast e)
2527     : CSSValue(PrimitiveClass)
2528 {
2529     m_primitiveUnitType = CSS_VALUE_ID;
2530     switch (e) {
2531     case TextAlignLastStart:
2532         m_value.valueID = CSSValueStart;
2533         break;
2534     case TextAlignLastEnd:
2535         m_value.valueID = CSSValueEnd;
2536         break;
2537     case TextAlignLastLeft:
2538         m_value.valueID = CSSValueLeft;
2539         break;
2540     case TextAlignLastRight:
2541         m_value.valueID = CSSValueRight;
2542         break;
2543     case TextAlignLastCenter:
2544         m_value.valueID = CSSValueCenter;
2545         break;
2546     case TextAlignLastJustify:
2547         m_value.valueID = CSSValueJustify;
2548         break;
2549     case TextAlignLastAuto:
2550         m_value.valueID = CSSValueAuto;
2551         break;
2552     }
2553 }
2554
2555 template<> inline CSSPrimitiveValue::operator TextAlignLast() const
2556 {
2557     ASSERT(isValueID());
2558
2559     switch (m_value.valueID) {
2560     case CSSValueAuto:
2561         return TextAlignLastAuto;
2562     case CSSValueStart:
2563         return TextAlignLastStart;
2564     case CSSValueEnd:
2565         return TextAlignLastEnd;
2566     case CSSValueLeft:
2567         return TextAlignLastLeft;
2568     case CSSValueRight:
2569         return TextAlignLastRight;
2570     case CSSValueCenter:
2571         return TextAlignLastCenter;
2572     case CSSValueJustify:
2573         return TextAlignLastJustify;
2574     default:
2575         break;
2576     }
2577
2578     ASSERT_NOT_REACHED();
2579     return TextAlignLastAuto;
2580 }
2581
2582 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextJustify e)
2583     : CSSValue(PrimitiveClass)
2584 {
2585     m_primitiveUnitType = CSS_VALUE_ID;
2586     switch (e) {
2587     case TextJustifyAuto:
2588         m_value.valueID = CSSValueAuto;
2589         break;
2590     case TextJustifyNone:
2591         m_value.valueID = CSSValueNone;
2592         break;
2593     case TextJustifyInterWord:
2594         m_value.valueID = CSSValueInterWord;
2595         break;
2596     case TextJustifyDistribute:
2597         m_value.valueID = CSSValueDistribute;
2598         break;
2599     }
2600 }
2601
2602 template<> inline CSSPrimitiveValue::operator TextJustify() const
2603 {
2604     ASSERT(isValueID());
2605
2606     switch (m_value.valueID) {
2607     case CSSValueAuto:
2608         return TextJustifyAuto;
2609     case CSSValueNone:
2610         return TextJustifyNone;
2611     case CSSValueInterWord:
2612         return TextJustifyInterWord;
2613     case CSSValueDistribute:
2614         return TextJustifyDistribute;
2615     default:
2616         break;
2617     }
2618
2619     ASSERT_NOT_REACHED();
2620     return TextJustifyAuto;
2621 }
2622 #endif // CSS3_TEXT
2623
2624 template<> inline CSSPrimitiveValue::operator TextDecoration() const
2625 {
2626     ASSERT(isValueID());
2627
2628     switch (m_value.valueID) {
2629     case CSSValueNone:
2630         return TextDecorationNone;
2631     case CSSValueUnderline:
2632         return TextDecorationUnderline;
2633     case CSSValueOverline:
2634         return TextDecorationOverline;
2635     case CSSValueLineThrough:
2636         return TextDecorationLineThrough;
2637     case CSSValueBlink:
2638         return TextDecorationBlink;
2639 #if ENABLE(LETTERPRESS)
2640     case CSSValueWebkitLetterpress:
2641         return TextDecorationLetterpress;
2642 #endif
2643     default:
2644         break;
2645     }
2646
2647     ASSERT_NOT_REACHED();
2648     return TextDecorationNone;
2649 }
2650
2651 template<> inline CSSPrimitiveValue::operator TextDecorationStyle() const
2652 {
2653     ASSERT(isValueID());
2654
2655     switch (m_value.valueID) {
2656     case CSSValueSolid:
2657         return TextDecorationStyleSolid;
2658     case CSSValueDouble:
2659         return TextDecorationStyleDouble;
2660     case CSSValueDotted:
2661         return TextDecorationStyleDotted;
2662     case CSSValueDashed:
2663         return TextDecorationStyleDashed;
2664     case CSSValueWavy:
2665         return TextDecorationStyleWavy;
2666     default:
2667         break;
2668     }
2669
2670     ASSERT_NOT_REACHED();
2671     return TextDecorationStyleSolid;
2672 }
2673
2674 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextUnderlinePosition e)
2675     : CSSValue(PrimitiveClass)
2676 {
2677     m_primitiveUnitType = CSS_VALUE_ID;
2678     switch (e) {
2679     case TextUnderlinePositionAuto:
2680         m_value.valueID = CSSValueAuto;
2681         break;
2682     case TextUnderlinePositionAlphabetic:
2683         m_value.valueID = CSSValueAlphabetic;
2684         break;
2685     case TextUnderlinePositionUnder:
2686         m_value.valueID = CSSValueUnder;
2687         break;
2688     }
2689
2690     // FIXME: Implement support for 'under left' and 'under right' values.
2691 }
2692
2693 template<> inline CSSPrimitiveValue::operator TextUnderlinePosition() const
2694 {
2695     ASSERT(isValueID());
2696
2697     switch (m_value.valueID) {
2698     case CSSValueAuto:
2699         return TextUnderlinePositionAuto;
2700     case CSSValueAlphabetic:
2701         return TextUnderlinePositionAlphabetic;
2702     case CSSValueUnder:
2703         return TextUnderlinePositionUnder;
2704     default:
2705         break;
2706     }
2707
2708     // FIXME: Implement support for 'under left' and 'under right' values.
2709
2710     ASSERT_NOT_REACHED();
2711     return TextUnderlinePositionAuto;
2712 }
2713
2714 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETextSecurity e)
2715     : CSSValue(PrimitiveClass)
2716 {
2717     m_primitiveUnitType = CSS_VALUE_ID;
2718     switch (e) {
2719     case TSNONE:
2720         m_value.valueID = CSSValueNone;
2721         break;
2722     case TSDISC:
2723         m_value.valueID = CSSValueDisc;
2724         break;
2725     case TSCIRCLE:
2726         m_value.valueID = CSSValueCircle;
2727         break;
2728     case TSSQUARE:
2729         m_value.valueID = CSSValueSquare;
2730         break;
2731     }
2732 }
2733
2734 template<> inline CSSPrimitiveValue::operator ETextSecurity() const
2735 {
2736     ASSERT(isValueID());
2737
2738     switch (m_value.valueID) {
2739     case CSSValueNone:
2740         return TSNONE;
2741     case CSSValueDisc:
2742         return TSDISC;
2743     case CSSValueCircle:
2744         return TSCIRCLE;
2745     case CSSValueSquare:
2746         return TSSQUARE;
2747     default:
2748         break;
2749     }
2750
2751     ASSERT_NOT_REACHED();
2752     return TSNONE;
2753 }
2754
2755 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETextTransform e)
2756     : CSSValue(PrimitiveClass)
2757 {
2758     m_primitiveUnitType = CSS_VALUE_ID;
2759     switch (e) {
2760     case CAPITALIZE:
2761         m_value.valueID = CSSValueCapitalize;
2762         break;
2763     case UPPERCASE:
2764         m_value.valueID = CSSValueUppercase;
2765         break;
2766     case LOWERCASE:
2767         m_value.valueID = CSSValueLowercase;
2768         break;
2769     case TTNONE:
2770         m_value.valueID = CSSValueNone;
2771         break;
2772     }
2773 }
2774
2775 template<> inline CSSPrimitiveValue::operator ETextTransform() const
2776 {
2777     ASSERT(isValueID());
2778
2779     switch (m_value.valueID) {
2780     case CSSValueCapitalize:
2781         return CAPITALIZE;
2782     case CSSValueUppercase:
2783         return UPPERCASE;
2784     case CSSValueLowercase:
2785         return LOWERCASE;
2786     case CSSValueNone:
2787         return TTNONE;
2788     default:
2789         break;
2790     }
2791
2792     ASSERT_NOT_REACHED();
2793     return TTNONE;
2794 }
2795
2796 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUnicodeBidi e)
2797     : CSSValue(PrimitiveClass)
2798 {
2799     m_primitiveUnitType = CSS_VALUE_ID;
2800     switch (e) {
2801     case UBNormal:
2802         m_value.valueID = CSSValueNormal;
2803         break;
2804     case Embed:
2805         m_value.valueID = CSSValueEmbed;
2806         break;
2807     case Override:
2808         m_value.valueID = CSSValueBidiOverride;
2809         break;
2810     case Isolate:
2811         m_value.valueID = CSSValueWebkitIsolate;
2812         break;
2813     case IsolateOverride:
2814         m_value.valueID = CSSValueWebkitIsolateOverride;
2815         break;
2816     case Plaintext:
2817         m_value.valueID = CSSValueWebkitPlaintext;
2818         break;
2819     }
2820 }
2821
2822 template<> inline CSSPrimitiveValue::operator EUnicodeBidi() const
2823 {
2824     ASSERT(isValueID());
2825
2826     switch (m_value.valueID) {
2827     case CSSValueNormal:
2828         return UBNormal;
2829     case CSSValueEmbed:
2830         return Embed;
2831     case CSSValueBidiOverride:
2832         return Override;
2833     case CSSValueWebkitIsolate:
2834         return Isolate;
2835     case CSSValueWebkitIsolateOverride:
2836         return IsolateOverride;
2837     case CSSValueWebkitPlaintext:
2838         return Plaintext;
2839     default:
2840         break;
2841     }
2842
2843     ASSERT_NOT_REACHED();
2844     return UBNormal;
2845 }
2846
2847 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUserDrag e)
2848     : CSSValue(PrimitiveClass)
2849 {
2850     m_primitiveUnitType = CSS_VALUE_ID;
2851     switch (e) {
2852     case DRAG_AUTO:
2853         m_value.valueID = CSSValueAuto;
2854         break;
2855     case DRAG_NONE:
2856         m_value.valueID = CSSValueNone;
2857         break;
2858     case DRAG_ELEMENT:
2859         m_value.valueID = CSSValueElement;
2860         break;
2861     default:
2862         break;
2863     }
2864 }
2865
2866 template<> inline CSSPrimitiveValue::operator EUserDrag() const
2867 {
2868     ASSERT(isValueID());
2869
2870     switch (m_value.valueID) {
2871     case CSSValueAuto:
2872         return DRAG_AUTO;
2873     case CSSValueNone:
2874         return DRAG_NONE;
2875     case CSSValueElement:
2876         return DRAG_ELEMENT;
2877     default:
2878         break;
2879     }
2880
2881     ASSERT_NOT_REACHED();
2882     return DRAG_AUTO;
2883 }
2884
2885 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUserModify e)
2886     : CSSValue(PrimitiveClass)
2887 {
2888     m_primitiveUnitType = CSS_VALUE_ID;
2889     switch (e) {
2890     case READ_ONLY:
2891         m_value.valueID = CSSValueReadOnly;
2892         break;
2893     case READ_WRITE:
2894         m_value.valueID = CSSValueReadWrite;
2895         break;
2896     case READ_WRITE_PLAINTEXT_ONLY:
2897         m_value.valueID = CSSValueReadWritePlaintextOnly;
2898         break;
2899     }
2900 }
2901
2902 template<> inline CSSPrimitiveValue::operator EUserModify() const
2903 {
2904     ASSERT(isValueID());
2905
2906     switch (m_value.valueID) {
2907     case CSSValueReadOnly:
2908         return READ_ONLY;
2909     case CSSValueReadWrite:
2910         return READ_WRITE;
2911     case CSSValueReadWritePlaintextOnly:
2912         return READ_WRITE_PLAINTEXT_ONLY;
2913     default:
2914         break;
2915     }
2916
2917     ASSERT_NOT_REACHED();
2918     return READ_ONLY;
2919 }
2920
2921 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUserSelect e)
2922     : CSSValue(PrimitiveClass)
2923 {
2924     m_primitiveUnitType = CSS_VALUE_ID;
2925     switch (e) {
2926     case SELECT_NONE:
2927         m_value.valueID = CSSValueNone;
2928         break;
2929     case SELECT_TEXT:
2930         m_value.valueID = CSSValueText;
2931         break;
2932     case SELECT_ALL:
2933         m_value.valueID = CSSValueAll;
2934         break;
2935     }
2936 }
2937
2938 template<> inline CSSPrimitiveValue::operator EUserSelect() const
2939 {
2940     ASSERT(isValueID());
2941
2942     switch (m_value.valueID) {
2943     case CSSValueAuto:
2944         return SELECT_TEXT;
2945     case CSSValueNone:
2946         return SELECT_NONE;
2947     case CSSValueText:
2948         return SELECT_TEXT;
2949     case CSSValueAll:
2950         return SELECT_ALL;
2951     default:
2952         break;
2953     }
2954
2955     ASSERT_NOT_REACHED();
2956     return SELECT_TEXT;
2957 }
2958
2959 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EVerticalAlign a)
2960     : CSSValue(PrimitiveClass)
2961 {
2962     m_primitiveUnitType = CSS_VALUE_ID;
2963     switch (a) {
2964     case TOP:
2965         m_value.valueID = CSSValueTop;
2966         break;
2967     case BOTTOM:
2968         m_value.valueID = CSSValueBottom;
2969         break;
2970     case MIDDLE:
2971         m_value.valueID = CSSValueMiddle;
2972         break;
2973     case BASELINE:
2974         m_value.valueID = CSSValueBaseline;
2975         break;
2976     case TEXT_BOTTOM:
2977         m_value.valueID = CSSValueTextBottom;
2978         break;
2979     case TEXT_TOP:
2980         m_value.valueID = CSSValueTextTop;
2981         break;
2982     case SUB:
2983         m_value.valueID = CSSValueSub;
2984         break;
2985     case SUPER:
2986         m_value.valueID = CSSValueSuper;
2987         break;
2988     case BASELINE_MIDDLE:
2989         m_value.valueID = CSSValueWebkitBaselineMiddle;
2990         break;
2991     case LENGTH:
2992         m_value.valueID = CSSValueInvalid;
2993     }
2994 }
2995
2996 template<> inline CSSPrimitiveValue::operator EVerticalAlign() const
2997 {
2998     ASSERT(isValueID());
2999
3000     switch (m_value.valueID) {
3001     case CSSValueTop:
3002         return TOP;
3003     case CSSValueBottom:
3004         return BOTTOM;
3005     case CSSValueMiddle:
3006         return MIDDLE;
3007     case CSSValueBaseline:
3008         return BASELINE;
3009     case CSSValueTextBottom:
3010         return TEXT_BOTTOM;
3011     case CSSValueTextTop:
3012         return TEXT_TOP;
3013     case CSSValueSub:
3014         return SUB;
3015     case CSSValueSuper:
3016         return SUPER;
3017     case CSSValueWebkitBaselineMiddle:
3018         return BASELINE_MIDDLE;
3019     default:
3020         break;
3021     }
3022
3023     ASSERT_NOT_REACHED();
3024     return TOP;
3025 }
3026
3027 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EVisibility e)
3028     : CSSValue(PrimitiveClass)
3029 {
3030     m_primitiveUnitType = CSS_VALUE_ID;
3031     switch (e) {
3032     case VISIBLE:
3033         m_value.valueID = CSSValueVisible;
3034         break;
3035     case HIDDEN:
3036         m_value.valueID = CSSValueHidden;
3037         break;
3038     case COLLAPSE:
3039         m_value.valueID = CSSValueCollapse;
3040         break;
3041     }
3042 }
3043
3044 template<> inline CSSPrimitiveValue::operator EVisibility() const
3045 {
3046     ASSERT(isValueID());
3047
3048     switch (m_value.valueID) {
3049     case CSSValueHidden:
3050         return HIDDEN;
3051     case CSSValueVisible:
3052         return VISIBLE;
3053     case CSSValueCollapse:
3054         return COLLAPSE;
3055     default:
3056         break;
3057     }
3058
3059     ASSERT_NOT_REACHED();
3060     return VISIBLE;
3061 }
3062
3063 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EWhiteSpace e)
3064     : CSSValue(PrimitiveClass)
3065 {
3066     m_primitiveUnitType = CSS_VALUE_ID;
3067     switch (e) {
3068     case NORMAL:
3069         m_value.valueID = CSSValueNormal;
3070         break;
3071     case PRE:
3072         m_value.valueID = CSSValuePre;
3073         break;
3074     case PRE_WRAP:
3075         m_value.valueID = CSSValuePreWrap;
3076         break;
3077     case PRE_LINE:
3078         m_value.valueID = CSSValuePreLine;
3079         break;
3080     case NOWRAP:
3081         m_value.valueID = CSSValueNowrap;
3082         break;
3083     case KHTML_NOWRAP:
3084         m_value.valueID = CSSValueWebkitNowrap;
3085         break;
3086     }
3087 }
3088
3089 template<> inline CSSPrimitiveValue::operator EWhiteSpace() const
3090 {
3091     ASSERT(isValueID());
3092
3093     switch (m_value.valueID) {
3094     case CSSValueWebkitNowrap:
3095         return KHTML_NOWRAP;
3096     case CSSValueNowrap:
3097         return NOWRAP;
3098     case CSSValuePre:
3099         return PRE;
3100     case CSSValuePreWrap:
3101         return PRE_WRAP;
3102     case CSSValuePreLine:
3103         return PRE_LINE;
3104     case CSSValueNormal:
3105         return NORMAL;
3106     default:
3107         break;
3108     }
3109
3110     ASSERT_NOT_REACHED();
3111     return NORMAL;
3112 }
3113
3114 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EWordBreak e)
3115     : CSSValue(PrimitiveClass)
3116 {
3117     m_primitiveUnitType = CSS_VALUE_ID;
3118     switch (e) {
3119     case NormalWordBreak:
3120         m_value.valueID = CSSValueNormal;
3121         break;
3122     case BreakAllWordBreak:
3123         m_value.valueID = CSSValueBreakAll;
3124         break;
3125     case KeepAllWordBreak:
3126         m_value.valueID = CSSValueKeepAll;
3127         break;
3128     case BreakWordBreak:
3129         m_value.valueID = CSSValueBreakWord;
3130         break;
3131     }
3132 }
3133
3134 template<> inline CSSPrimitiveValue::operator EWordBreak() const
3135 {
3136     ASSERT(isValueID());
3137
3138     switch (m_value.valueID) {
3139     case CSSValueBreakAll:
3140         return BreakAllWordBreak;
3141     case CSSValueKeepAll:
3142         return KeepAllWordBreak;
3143     case CSSValueBreakWord:
3144         return BreakWordBreak;
3145     case CSSValueNormal:
3146         return NormalWordBreak;
3147     default:
3148         break;
3149     }
3150
3151     ASSERT_NOT_REACHED();
3152     return NormalWordBreak;
3153 }
3154
3155 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EOverflowWrap e)
3156     : CSSValue(PrimitiveClass)
3157 {
3158     m_primitiveUnitType = CSS_VALUE_ID;
3159     switch (e) {
3160     case NormalOverflowWrap:
3161         m_value.valueID = CSSValueNormal;
3162         break;
3163     case BreakOverflowWrap:
3164         m_value.valueID = CSSValueBreakWord;
3165         break;
3166     }
3167 }
3168
3169 template<> inline CSSPrimitiveValue::operator EOverflowWrap() const
3170 {
3171     ASSERT(isValueID());
3172
3173     switch (m_value.valueID) {
3174     case CSSValueBreakWord:
3175         return BreakOverflowWrap;
3176     case CSSValueNormal:
3177         return NormalOverflowWrap;
3178     default:
3179         break;
3180     }
3181
3182     ASSERT_NOT_REACHED();
3183     return NormalOverflowWrap;
3184 }
3185
3186 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextDirection e)
3187     : CSSValue(PrimitiveClass)
3188 {
3189     m_primitiveUnitType = CSS_VALUE_ID;
3190     switch (e) {
3191     case LTR:
3192         m_value.valueID = CSSValueLtr;
3193         break;
3194     case RTL:
3195         m_value.valueID = CSSValueRtl;
3196         break;
3197     }
3198 }
3199
3200 template<> inline CSSPrimitiveValue::operator TextDirection() const
3201 {
3202     ASSERT(isValueID());
3203
3204     switch (m_value.valueID) {
3205     case CSSValueLtr:
3206         return LTR;
3207     case CSSValueRtl:
3208         return RTL;
3209     default:
3210         break;
3211     }
3212
3213     ASSERT_NOT_REACHED();
3214     return LTR;
3215 }
3216
3217 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(WritingMode e)
3218     : CSSValue(PrimitiveClass)
3219 {
3220     m_primitiveUnitType = CSS_VALUE_ID;
3221     switch (e) {
3222     case TopToBottomWritingMode:
3223         m_value.valueID = CSSValueHorizontalTb;
3224         break;
3225     case RightToLeftWritingMode:
3226         m_value.valueID = CSSValueVerticalRl;
3227         break;
3228     case LeftToRightWritingMode:
3229         m_value.valueID = CSSValueVerticalLr;
3230         break;
3231     case BottomToTopWritingMode:
3232         m_value.valueID = CSSValueHorizontalBt;
3233         break;
3234     }
3235 }
3236
3237 template<> inline CSSPrimitiveValue::operator WritingMode() const
3238 {
3239     ASSERT(isValueID());
3240
3241     switch (m_value.valueID) {
3242     case CSSValueHorizontalTb:
3243     case CSSValueLrTb:
3244     case CSSValueRl:
3245     case CSSValueRlTb:
3246         return TopToBottomWritingMode;
3247     case CSSValueVerticalRl:
3248     case CSSValueTb:
3249     case CSSValueTbRl:
3250         return RightToLeftWritingMode;
3251     case CSSValueVerticalLr:
3252         return LeftToRightWritingMode;
3253     case CSSValueHorizontalBt:
3254         return BottomToTopWritingMode;
3255     default:
3256         break;
3257     }
3258
3259     ASSERT_NOT_REACHED();
3260     return TopToBottomWritingMode;
3261 }
3262
3263 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextCombine e)
3264     : CSSValue(PrimitiveClass)
3265 {
3266     m_primitiveUnitType = CSS_VALUE_ID;
3267     switch (e) {
3268     case TextCombineNone:
3269         m_value.valueID = CSSValueNone;
3270         break;
3271     case TextCombineHorizontal:
3272         m_value.valueID = CSSValueHorizontal;
3273         break;
3274     }
3275 }
3276
3277 template<> inline CSSPrimitiveValue::operator TextCombine() const
3278 {
3279     ASSERT(isValueID());
3280
3281     switch (m_value.valueID) {
3282     case CSSValueNone:
3283         return TextCombineNone;
3284     case CSSValueHorizontal:
3285         return TextCombineHorizontal;
3286     default:
3287         break;
3288     }
3289
3290     ASSERT_NOT_REACHED();
3291     return TextCombineNone;
3292 }
3293
3294 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(RubyPosition position)
3295     : CSSValue(PrimitiveClass)
3296 {
3297     m_primitiveUnitType = CSS_VALUE_ID;
3298     switch (position) {
3299     case RubyPositionBefore:
3300         m_value.valueID = CSSValueBefore;
3301         break;
3302     case RubyPositionAfter:
3303         m_value.valueID = CSSValueAfter;
3304         break;
3305     case RubyPositionInterCharacter:
3306         m_value.valueID = CSSValueInterCharacter;
3307         break;
3308     }
3309 }
3310
3311 template<> inline CSSPrimitiveValue::operator RubyPosition() const
3312 {
3313     ASSERT(isValueID());
3314
3315     switch (m_value.valueID) {
3316     case CSSValueBefore:
3317         return RubyPositionBefore;
3318     case CSSValueAfter:
3319         return RubyPositionAfter;
3320     case CSSValueInterCharacter:
3321         return RubyPositionInterCharacter;
3322     default:
3323         break;
3324     }
3325
3326     ASSERT_NOT_REACHED();
3327     return RubyPositionBefore;
3328 }
3329
3330 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextOverflow overflow)
3331     : CSSValue(PrimitiveClass)
3332 {
3333     m_primitiveUnitType = CSS_VALUE_ID;
3334     switch (overflow) {
3335     case TextOverflowClip:
3336         m_value.valueID = CSSValueClip;
3337         break;
3338     case TextOverflowEllipsis:
3339         m_value.valueID = CSSValueEllipsis;
3340         break;
3341     }
3342 }
3343
3344 template<> inline CSSPrimitiveValue::operator TextOverflow() const
3345 {
3346     ASSERT(isValueID());
3347
3348     switch (m_value.valueID) {
3349     case CSSValueClip:
3350         return TextOverflowClip;
3351     case CSSValueEllipsis:
3352         return TextOverflowEllipsis;
3353     default:
3354         break;
3355     }
3356
3357     ASSERT_NOT_REACHED();
3358     return TextOverflowClip;
3359 }
3360
3361 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextEmphasisFill fill)
3362     : CSSValue(PrimitiveClass)
3363 {
3364     m_primitiveUnitType = CSS_VALUE_ID;
3365     switch (fill) {
3366     case TextEmphasisFillFilled:
3367         m_value.valueID = CSSValueFilled;
3368         break;
3369     case TextEmphasisFillOpen:
3370         m_value.valueID = CSSValueOpen;
3371         break;
3372     }
3373 }
3374
3375 template<> inline CSSPrimitiveValue::operator TextEmphasisFill() const
3376 {
3377     ASSERT(isValueID());
3378
3379     switch (m_value.valueID) {
3380     case CSSValueFilled:
3381         return TextEmphasisFillFilled;
3382     case CSSValueOpen:
3383         return TextEmphasisFillOpen;
3384     default:
3385         break;
3386     }
3387
3388     ASSERT_NOT_REACHED();
3389     return TextEmphasisFillFilled;
3390 }
3391
3392 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextEmphasisMark mark)
3393     : CSSValue(PrimitiveClass)
3394 {
3395     m_primitiveUnitType = CSS_VALUE_ID;
3396     switch (mark) {
3397     case TextEmphasisMarkDot:
3398         m_value.valueID = CSSValueDot;
3399         break;
3400     case TextEmphasisMarkCircle:
3401         m_value.valueID = CSSValueCircle;
3402         break;
3403     case TextEmphasisMarkDoubleCircle:
3404         m_value.valueID = CSSValueDoubleCircle;
3405         break;
3406     case TextEmphasisMarkTriangle:
3407         m_value.valueID = CSSValueTriangle;
3408         break;
3409     case TextEmphasisMarkSesame:
3410         m_value.valueID = CSSValueSesame;
3411         break;
3412     case TextEmphasisMarkNone:
3413     case TextEmphasisMarkAuto:
3414     case TextEmphasisMarkCustom:
3415         ASSERT_NOT_REACHED();
3416         m_value.valueID = CSSValueNone;
3417         break;
3418     }
3419 }
3420
3421 template<> inline CSSPrimitiveValue::operator TextEmphasisMark() const
3422 {
3423     ASSERT(isValueID());
3424
3425     switch (m_value.valueID) {
3426     case CSSValueNone:
3427         return TextEmphasisMarkNone;
3428     case CSSValueDot:
3429         return TextEmphasisMarkDot;
3430     case CSSValueCircle:
3431         return TextEmphasisMarkCircle;
3432     case CSSValueDoubleCircle:
3433         return TextEmphasisMarkDoubleCircle;
3434     case CSSValueTriangle:
3435         return TextEmphasisMarkTriangle;
3436     case CSSValueSesame:
3437         return TextEmphasisMarkSesame;
3438     default:
3439         break;
3440     }
3441
3442     ASSERT_NOT_REACHED();
3443     return TextEmphasisMarkNone;
3444 }
3445
3446 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextOrientation e)
3447     : CSSValue(PrimitiveClass)
3448 {
3449     m_primitiveUnitType = CSS_VALUE_ID;
3450     switch (e) {
3451     case TextOrientation::Sideways:
3452         m_value.valueID = CSSValueSideways;
3453         break;
3454     case TextOrientation::Mixed:
3455         m_value.valueID = CSSValueMixed;
3456         break;
3457     case TextOrientation::Upright:
3458         m_value.valueID = CSSValueUpright;
3459         break;
3460     }
3461 }
3462
3463 template<> inline CSSPrimitiveValue::operator TextOrientation() const
3464 {
3465     ASSERT(isValueID());
3466
3467     switch (m_value.valueID) {
3468     case CSSValueSideways:
3469         return TextOrientation::Sideways;
3470     case CSSValueSidewaysRight:
3471         return TextOrientation::Sideways;
3472     case CSSValueVerticalRight:
3473         return TextOrientation::Mixed;
3474     case CSSValueMixed:
3475         return TextOrientation::Mixed;
3476     case CSSValueUpright:
3477         return TextOrientation::Upright;
3478     default:
3479         break;
3480     }
3481
3482     ASSERT_NOT_REACHED();
3483     return TextOrientation::Mixed;
3484 }
3485
3486 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EPointerEvents e)
3487     : CSSValue(PrimitiveClass)
3488 {
3489     m_primitiveUnitType = CSS_VALUE_ID;
3490     switch (e) {
3491     case PE_NONE:
3492         m_value.valueID = CSSValueNone;
3493         break;
3494     case PE_STROKE:
3495         m_value.valueID = CSSValueStroke;
3496         break;
3497     case PE_FILL:
3498         m_value.valueID = CSSValueFill;
3499         break;
3500     case PE_PAINTED:
3501         m_value.valueID = CSSValuePainted;
3502         break;
3503     case PE_VISIBLE:
3504         m_value.valueID = CSSValueVisible;
3505         break;
3506     case PE_VISIBLE_STROKE:
3507         m_value.valueID = CSSValueVisiblestroke;
3508         break;
3509     case PE_VISIBLE_FILL:
3510         m_value.valueID = CSSValueVisiblefill;
3511         break;
3512     case PE_VISIBLE_PAINTED:
3513         m_value.valueID = CSSValueVisiblepainted;
3514         break;
3515     case PE_AUTO:
3516         m_value.valueID = CSSValueAuto;
3517         break;
3518     case PE_ALL:
3519         m_value.valueID = CSSValueAll;
3520         break;
3521     }
3522 }
3523
3524 template<> inline CSSPrimitiveValue::operator EPointerEvents() const
3525 {
3526     ASSERT(isValueID());
3527
3528     switch (m_value.valueID) {
3529     case CSSValueAll:
3530         return PE_ALL;
3531     case CSSValueAuto:
3532         return PE_AUTO;
3533     case CSSValueNone:
3534         return PE_NONE;
3535     case CSSValueVisiblepainted:
3536         return PE_VISIBLE_PAINTED;
3537     case CSSValueVisiblefill:
3538         return PE_VISIBLE_FILL;
3539     case CSSValueVisiblestroke:
3540         return PE_VISIBLE_STROKE;
3541     case CSSValueVisible:
3542         return PE_VISIBLE;
3543     case CSSValuePainted:
3544         return PE_PAINTED;
3545     case CSSValueFill:
3546         return PE_FILL;
3547     case CSSValueStroke:
3548         return PE_STROKE;
3549     default:
3550         break;
3551     }
3552
3553     ASSERT_NOT_REACHED();
3554     return PE_ALL;
3555 }
3556
3557 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(Kerning kerning)
3558     : CSSValue(PrimitiveClass)
3559 {
3560     m_primitiveUnitType = CSS_VALUE_ID;
3561     switch (kerning) {
3562     case Kerning::Auto:
3563         m_value.valueID = CSSValueAuto;
3564         return;
3565     case Kerning::Normal:
3566         m_value.valueID = CSSValueNormal;
3567         return;
3568     case Kerning::NoShift:
3569         m_value.valueID = CSSValueNone;
3570         return;
3571     }
3572
3573     ASSERT_NOT_REACHED();
3574     m_value.valueID = CSSValueAuto;
3575 }
3576
3577 template<> inline CSSPrimitiveValue::operator Kerning() const
3578 {
3579     ASSERT(isValueID());
3580
3581     switch (m_value.valueID) {
3582     case CSSValueAuto:
3583         return Kerning::Auto;
3584     case CSSValueNormal:
3585         return Kerning::Normal;
3586     case CSSValueNone:
3587         return Kerning::NoShift;
3588     default:
3589         break;
3590     }
3591
3592     ASSERT_NOT_REACHED();
3593     return Kerning::Auto;
3594 }
3595
3596 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ObjectFit fit)
3597     : CSSValue(PrimitiveClass)
3598 {
3599     m_primitiveUnitType = CSS_VALUE_ID;
3600     switch (fit) {