cce8e9b5991c8b8a93285b00e268cb80aed71a4d
[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     case GRID:
1383         m_value.valueID = CSSValueGrid;
1384         break;
1385     case INLINE_GRID:
1386         m_value.valueID = CSSValueInlineGrid;
1387         break;
1388     case NONE:
1389         m_value.valueID = CSSValueNone;
1390         break;
1391     case CONTENTS:
1392         m_value.valueID = CSSValueContents;
1393         break;
1394     }
1395 }
1396
1397 template<> inline CSSPrimitiveValue::operator EDisplay() const
1398 {
1399     ASSERT(isValueID());
1400
1401     if (m_value.valueID == CSSValueNone)
1402         return NONE;
1403
1404     EDisplay display = static_cast<EDisplay>(m_value.valueID - CSSValueInline);
1405     ASSERT(display >= INLINE && display <= NONE);
1406     if (display == WEBKIT_FLEX)
1407         return FLEX;
1408     if (display == WEBKIT_INLINE_FLEX)
1409         return INLINE_FLEX;
1410     return display;
1411 }
1412
1413 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EEmptyCell e)
1414     : CSSValue(PrimitiveClass)
1415 {
1416     m_primitiveUnitType = CSS_VALUE_ID;
1417     switch (e) {
1418     case SHOW:
1419         m_value.valueID = CSSValueShow;
1420         break;
1421     case HIDE:
1422         m_value.valueID = CSSValueHide;
1423         break;
1424     }
1425 }
1426
1427 template<> inline CSSPrimitiveValue::operator EEmptyCell() const
1428 {
1429     ASSERT(isValueID());
1430
1431     switch (m_value.valueID) {
1432     case CSSValueShow:
1433         return SHOW;
1434     case CSSValueHide:
1435         return HIDE;
1436     default:
1437         break;
1438     }
1439
1440     ASSERT_NOT_REACHED();
1441     return SHOW;
1442 }
1443
1444 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFlexDirection e)
1445     : CSSValue(PrimitiveClass)
1446 {
1447     m_primitiveUnitType = CSS_VALUE_ID;
1448     switch (e) {
1449     case FlowRow:
1450         m_value.valueID = CSSValueRow;
1451         break;
1452     case FlowRowReverse:
1453         m_value.valueID = CSSValueRowReverse;
1454         break;
1455     case FlowColumn:
1456         m_value.valueID = CSSValueColumn;
1457         break;
1458     case FlowColumnReverse:
1459         m_value.valueID = CSSValueColumnReverse;
1460         break;
1461     }
1462 }
1463
1464 template<> inline CSSPrimitiveValue::operator EFlexDirection() const
1465 {
1466     ASSERT(isValueID());
1467
1468     switch (m_value.valueID) {
1469     case CSSValueRow:
1470         return FlowRow;
1471     case CSSValueRowReverse:
1472         return FlowRowReverse;
1473     case CSSValueColumn:
1474         return FlowColumn;
1475     case CSSValueColumnReverse:
1476         return FlowColumnReverse;
1477     default:
1478         break;
1479     }
1480
1481     ASSERT_NOT_REACHED();
1482     return FlowRow;
1483 }
1484
1485 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EAlignContent e)
1486     : CSSValue(PrimitiveClass)
1487 {
1488     m_primitiveUnitType = CSS_VALUE_ID;
1489     switch (e) {
1490     case AlignContentFlexStart:
1491         m_value.valueID = CSSValueFlexStart;
1492         break;
1493     case AlignContentFlexEnd:
1494         m_value.valueID = CSSValueFlexEnd;
1495         break;
1496     case AlignContentCenter:
1497         m_value.valueID = CSSValueCenter;
1498         break;
1499     case AlignContentSpaceBetween:
1500         m_value.valueID = CSSValueSpaceBetween;
1501         break;
1502     case AlignContentSpaceAround:
1503         m_value.valueID = CSSValueSpaceAround;
1504         break;
1505     case AlignContentStretch:
1506         m_value.valueID = CSSValueStretch;
1507         break;
1508     }
1509 }
1510
1511 template<> inline CSSPrimitiveValue::operator EAlignContent() const
1512 {
1513     ASSERT(isValueID());
1514
1515     switch (m_value.valueID) {
1516     case CSSValueFlexStart:
1517         return AlignContentFlexStart;
1518     case CSSValueFlexEnd:
1519         return AlignContentFlexEnd;
1520     case CSSValueCenter:
1521         return AlignContentCenter;
1522     case CSSValueSpaceBetween:
1523         return AlignContentSpaceBetween;
1524     case CSSValueSpaceAround:
1525         return AlignContentSpaceAround;
1526     case CSSValueStretch:
1527         return AlignContentStretch;
1528     default:
1529         break;
1530     }
1531
1532     ASSERT_NOT_REACHED();
1533     return AlignContentStretch;
1534 }
1535
1536 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFlexWrap e)
1537     : CSSValue(PrimitiveClass)
1538 {
1539     m_primitiveUnitType = CSS_VALUE_ID;
1540     switch (e) {
1541     case FlexNoWrap:
1542         m_value.valueID = CSSValueNowrap;
1543         break;
1544     case FlexWrap:
1545         m_value.valueID = CSSValueWrap;
1546         break;
1547     case FlexWrapReverse:
1548         m_value.valueID = CSSValueWrapReverse;
1549         break;
1550     }
1551 }
1552
1553 template<> inline CSSPrimitiveValue::operator EFlexWrap() const
1554 {
1555     ASSERT(isValueID());
1556
1557     switch (m_value.valueID) {
1558     case CSSValueNowrap:
1559         return FlexNoWrap;
1560     case CSSValueWrap:
1561         return FlexWrap;
1562     case CSSValueWrapReverse:
1563         return FlexWrapReverse;
1564     default:
1565         break;
1566     }
1567
1568     ASSERT_NOT_REACHED();
1569     return FlexNoWrap;
1570 }
1571
1572 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFloat e)
1573     : CSSValue(PrimitiveClass)
1574 {
1575     m_primitiveUnitType = CSS_VALUE_ID;
1576     switch (e) {
1577     case NoFloat:
1578         m_value.valueID = CSSValueNone;
1579         break;
1580     case LeftFloat:
1581         m_value.valueID = CSSValueLeft;
1582         break;
1583     case RightFloat:
1584         m_value.valueID = CSSValueRight;
1585         break;
1586     }
1587 }
1588
1589 template<> inline CSSPrimitiveValue::operator EFloat() const
1590 {
1591     ASSERT(isValueID());
1592
1593     switch (m_value.valueID) {
1594     case CSSValueLeft:
1595         return LeftFloat;
1596     case CSSValueRight:
1597         return RightFloat;
1598     case CSSValueNone:
1599     case CSSValueCenter: // Non-standard CSS value.
1600         return NoFloat;
1601     default:
1602         break;
1603     }
1604
1605     ASSERT_NOT_REACHED();
1606     return NoFloat;
1607 }
1608
1609 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineBreak e)
1610     : CSSValue(PrimitiveClass)
1611 {
1612     m_primitiveUnitType = CSS_VALUE_ID;
1613     switch (e) {
1614     case LineBreakAuto:
1615         m_value.valueID = CSSValueAuto;
1616         break;
1617     case LineBreakLoose:
1618         m_value.valueID = CSSValueLoose;
1619         break;
1620     case LineBreakNormal:
1621         m_value.valueID = CSSValueNormal;
1622         break;
1623     case LineBreakStrict:
1624         m_value.valueID = CSSValueStrict;
1625         break;
1626     case LineBreakAfterWhiteSpace:
1627         m_value.valueID = CSSValueAfterWhiteSpace;
1628         break;
1629     }
1630 }
1631
1632 template<> inline CSSPrimitiveValue::operator HangingPunctuation() const
1633 {
1634     ASSERT(isValueID());
1635     
1636     switch (m_value.valueID) {
1637     case CSSValueNone:
1638         return NoHangingPunctuation;
1639     case CSSValueFirst:
1640         return FirstHangingPunctuation;
1641     case CSSValueLast:
1642         return LastHangingPunctuation;
1643     case CSSValueAllowEnd:
1644         return AllowEndHangingPunctuation;
1645     case CSSValueForceEnd:
1646         return ForceEndHangingPunctuation;
1647     default:
1648         break;
1649     }
1650     
1651     ASSERT_NOT_REACHED();
1652     return NoHangingPunctuation;
1653 }
1654
1655 template<> inline CSSPrimitiveValue::operator LineBreak() const
1656 {
1657     ASSERT(isValueID());
1658
1659     switch (m_value.valueID) {
1660     case CSSValueAuto:
1661         return LineBreakAuto;
1662     case CSSValueLoose:
1663         return LineBreakLoose;
1664     case CSSValueNormal:
1665         return LineBreakNormal;
1666     case CSSValueStrict:
1667         return LineBreakStrict;
1668     case CSSValueAfterWhiteSpace:
1669         return LineBreakAfterWhiteSpace;
1670     default:
1671         break;
1672     }
1673
1674     ASSERT_NOT_REACHED();
1675     return LineBreakAuto;
1676 }
1677
1678 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EListStylePosition e)
1679     : CSSValue(PrimitiveClass)
1680 {
1681     m_primitiveUnitType = CSS_VALUE_ID;
1682     switch (e) {
1683     case OUTSIDE:
1684         m_value.valueID = CSSValueOutside;
1685         break;
1686     case INSIDE:
1687         m_value.valueID = CSSValueInside;
1688         break;
1689     }
1690 }
1691
1692 template<> inline CSSPrimitiveValue::operator EListStylePosition() const
1693 {
1694     ASSERT(isValueID());
1695
1696     switch (m_value.valueID) {
1697     case CSSValueOutside:
1698         return OUTSIDE;
1699     case CSSValueInside:
1700         return INSIDE;
1701     default:
1702         break;
1703     }
1704
1705     ASSERT_NOT_REACHED();
1706     return OUTSIDE;
1707 }
1708
1709 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EListStyleType e)
1710     : CSSValue(PrimitiveClass)
1711 {
1712     m_primitiveUnitType = CSS_VALUE_ID;
1713     switch (e) {
1714     case Afar:
1715         m_value.valueID = CSSValueAfar;
1716         break;
1717     case Amharic:
1718         m_value.valueID = CSSValueAmharic;
1719         break;
1720     case AmharicAbegede:
1721         m_value.valueID = CSSValueAmharicAbegede;
1722         break;
1723     case ArabicIndic:
1724         m_value.valueID = CSSValueArabicIndic;
1725         break;
1726     case Armenian:
1727         m_value.valueID = CSSValueArmenian;
1728         break;
1729     case Asterisks:
1730         m_value.valueID = CSSValueAsterisks;
1731         break;
1732     case BinaryListStyle:
1733         m_value.valueID = CSSValueBinary;
1734         break;
1735     case Bengali:
1736         m_value.valueID = CSSValueBengali;
1737         break;
1738     case Cambodian:
1739         m_value.valueID = CSSValueCambodian;
1740         break;
1741     case Circle:
1742         m_value.valueID = CSSValueCircle;
1743         break;
1744     case CjkEarthlyBranch:
1745         m_value.valueID = CSSValueCjkEarthlyBranch;
1746         break;
1747     case CjkHeavenlyStem:
1748         m_value.valueID = CSSValueCjkHeavenlyStem;
1749         break;
1750     case CJKIdeographic:
1751         m_value.valueID = CSSValueCjkIdeographic;
1752         break;
1753     case DecimalLeadingZero:
1754         m_value.valueID = CSSValueDecimalLeadingZero;
1755         break;
1756     case DecimalListStyle:
1757         m_value.valueID = CSSValueDecimal;
1758         break;
1759     case Devanagari:
1760         m_value.valueID = CSSValueDevanagari;
1761         break;
1762     case Disc:
1763         m_value.valueID = CSSValueDisc;
1764         break;
1765     case Ethiopic:
1766         m_value.valueID = CSSValueEthiopic;
1767         break;
1768     case EthiopicAbegede:
1769         m_value.valueID = CSSValueEthiopicAbegede;
1770         break;
1771     case EthiopicAbegedeAmEt:
1772         m_value.valueID = CSSValueEthiopicAbegedeAmEt;
1773         break;
1774     case EthiopicAbegedeGez:
1775         m_value.valueID = CSSValueEthiopicAbegedeGez;
1776         break;
1777     case EthiopicAbegedeTiEr:
1778         m_value.valueID = CSSValueEthiopicAbegedeTiEr;
1779         break;
1780     case EthiopicAbegedeTiEt:
1781         m_value.valueID = CSSValueEthiopicAbegedeTiEt;
1782         break;
1783     case EthiopicHalehameAaEr:
1784         m_value.valueID = CSSValueEthiopicHalehameAaEr;
1785         break;
1786     case EthiopicHalehameAaEt:
1787         m_value.valueID = CSSValueEthiopicHalehameAaEt;
1788         break;
1789     case EthiopicHalehameAmEt:
1790         m_value.valueID = CSSValueEthiopicHalehameAmEt;
1791         break;
1792     case EthiopicHalehameGez:
1793         m_value.valueID = CSSValueEthiopicHalehameGez;
1794         break;
1795     case EthiopicHalehameOmEt:
1796         m_value.valueID = CSSValueEthiopicHalehameOmEt;
1797         break;
1798     case EthiopicHalehameSidEt:
1799         m_value.valueID = CSSValueEthiopicHalehameSidEt;
1800         break;
1801     case EthiopicHalehameSoEt:
1802         m_value.valueID = CSSValueEthiopicHalehameSoEt;
1803         break;
1804     case EthiopicHalehameTiEr:
1805         m_value.valueID = CSSValueEthiopicHalehameTiEr;
1806         break;
1807     case EthiopicHalehameTiEt:
1808         m_value.valueID = CSSValueEthiopicHalehameTiEt;
1809         break;
1810     case EthiopicHalehameTig:
1811         m_value.valueID = CSSValueEthiopicHalehameTig;
1812         break;
1813     case Footnotes:
1814         m_value.valueID = CSSValueFootnotes;
1815         break;
1816     case Georgian:
1817         m_value.valueID = CSSValueGeorgian;
1818         break;
1819     case Gujarati:
1820         m_value.valueID = CSSValueGujarati;
1821         break;
1822     case Gurmukhi:
1823         m_value.valueID = CSSValueGurmukhi;
1824         break;
1825     case Hangul:
1826         m_value.valueID = CSSValueHangul;
1827         break;
1828     case HangulConsonant:
1829         m_value.valueID = CSSValueHangulConsonant;
1830         break;
1831     case Hebrew:
1832         m_value.valueID = CSSValueHebrew;
1833         break;
1834     case Hiragana:
1835         m_value.valueID = CSSValueHiragana;
1836         break;
1837     case HiraganaIroha:
1838         m_value.valueID = CSSValueHiraganaIroha;
1839         break;
1840     case Kannada:
1841         m_value.valueID = CSSValueKannada;
1842         break;
1843     case Katakana:
1844         m_value.valueID = CSSValueKatakana;
1845         break;
1846     case KatakanaIroha:
1847         m_value.valueID = CSSValueKatakanaIroha;
1848         break;
1849     case Khmer:
1850         m_value.valueID = CSSValueKhmer;
1851         break;
1852     case Lao:
1853         m_value.valueID = CSSValueLao;
1854         break;
1855     case LowerAlpha:
1856         m_value.valueID = CSSValueLowerAlpha;
1857         break;
1858     case LowerArmenian:
1859         m_value.valueID = CSSValueLowerArmenian;
1860         break;
1861     case LowerGreek:
1862         m_value.valueID = CSSValueLowerGreek;
1863         break;
1864     case LowerHexadecimal:
1865         m_value.valueID = CSSValueLowerHexadecimal;
1866         break;
1867     case LowerLatin:
1868         m_value.valueID = CSSValueLowerLatin;
1869         break;
1870     case LowerNorwegian:
1871         m_value.valueID = CSSValueLowerNorwegian;
1872         break;
1873     case LowerRoman:
1874         m_value.valueID = CSSValueLowerRoman;
1875         break;
1876     case Malayalam:
1877         m_value.valueID = CSSValueMalayalam;
1878         break;
1879     case Mongolian:
1880         m_value.valueID = CSSValueMongolian;
1881         break;
1882     case Myanmar:
1883         m_value.valueID = CSSValueMyanmar;
1884         break;
1885     case NoneListStyle:
1886         m_value.valueID = CSSValueNone;
1887         break;
1888     case Octal:
1889         m_value.valueID = CSSValueOctal;
1890         break;
1891     case Oriya:
1892         m_value.valueID = CSSValueOriya;
1893         break;
1894     case Oromo:
1895         m_value.valueID = CSSValueOromo;
1896         break;
1897     case Persian:
1898         m_value.valueID = CSSValuePersian;
1899         break;
1900     case Sidama:
1901         m_value.valueID = CSSValueSidama;
1902         break;
1903     case Somali:
1904         m_value.valueID = CSSValueSomali;
1905         break;
1906     case Square:
1907         m_value.valueID = CSSValueSquare;
1908         break;
1909     case Telugu:
1910         m_value.valueID = CSSValueTelugu;
1911         break;
1912     case Thai:
1913         m_value.valueID = CSSValueThai;
1914         break;
1915     case Tibetan:
1916         m_value.valueID = CSSValueTibetan;
1917         break;
1918     case Tigre:
1919         m_value.valueID = CSSValueTigre;
1920         break;
1921     case TigrinyaEr:
1922         m_value.valueID = CSSValueTigrinyaEr;
1923         break;
1924     case TigrinyaErAbegede:
1925         m_value.valueID = CSSValueTigrinyaErAbegede;
1926         break;
1927     case TigrinyaEt:
1928         m_value.valueID = CSSValueTigrinyaEt;
1929         break;
1930     case TigrinyaEtAbegede:
1931         m_value.valueID = CSSValueTigrinyaEtAbegede;
1932         break;
1933     case UpperAlpha:
1934         m_value.valueID = CSSValueUpperAlpha;
1935         break;
1936     case UpperArmenian:
1937         m_value.valueID = CSSValueUpperArmenian;
1938         break;
1939     case UpperGreek:
1940         m_value.valueID = CSSValueUpperGreek;
1941         break;
1942     case UpperHexadecimal:
1943         m_value.valueID = CSSValueUpperHexadecimal;
1944         break;
1945     case UpperLatin:
1946         m_value.valueID = CSSValueUpperLatin;
1947         break;
1948     case UpperNorwegian:
1949         m_value.valueID = CSSValueUpperNorwegian;
1950         break;
1951     case UpperRoman:
1952         m_value.valueID = CSSValueUpperRoman;
1953         break;
1954     case Urdu:
1955         m_value.valueID = CSSValueUrdu;
1956         break;
1957     }
1958 }
1959
1960 template<> inline CSSPrimitiveValue::operator EListStyleType() const
1961 {
1962     ASSERT(isValueID());
1963
1964     switch (m_value.valueID) {
1965     case CSSValueNone:
1966         return NoneListStyle;
1967     default:
1968         return static_cast<EListStyleType>(m_value.valueID - CSSValueDisc);
1969     }
1970 }
1971
1972 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EMarginCollapse e)
1973     : CSSValue(PrimitiveClass)
1974 {
1975     m_primitiveUnitType = CSS_VALUE_ID;
1976     switch (e) {
1977     case MCOLLAPSE:
1978         m_value.valueID = CSSValueCollapse;
1979         break;
1980     case MSEPARATE:
1981         m_value.valueID = CSSValueSeparate;
1982         break;
1983     case MDISCARD:
1984         m_value.valueID = CSSValueDiscard;
1985         break;
1986     }
1987 }
1988
1989 template<> inline CSSPrimitiveValue::operator EMarginCollapse() const
1990 {
1991     ASSERT(isValueID());
1992
1993     switch (m_value.valueID) {
1994     case CSSValueCollapse:
1995         return MCOLLAPSE;
1996     case CSSValueSeparate:
1997         return MSEPARATE;
1998     case CSSValueDiscard:
1999         return MDISCARD;
2000     default:
2001         break;
2002     }
2003
2004     ASSERT_NOT_REACHED();
2005     return MCOLLAPSE;
2006 }
2007
2008 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EMarqueeBehavior e)
2009     : CSSValue(PrimitiveClass)
2010 {
2011     m_primitiveUnitType = CSS_VALUE_ID;
2012     switch (e) {
2013     case MNONE:
2014         m_value.valueID = CSSValueNone;
2015         break;
2016     case MSCROLL:
2017         m_value.valueID = CSSValueScroll;
2018         break;
2019     case MSLIDE:
2020         m_value.valueID = CSSValueSlide;
2021         break;
2022     case MALTERNATE:
2023         m_value.valueID = CSSValueAlternate;
2024         break;
2025     }
2026 }
2027
2028 template<> inline CSSPrimitiveValue::operator EMarqueeBehavior() const
2029 {
2030     ASSERT(isValueID());
2031
2032     switch (m_value.valueID) {
2033     case CSSValueNone:
2034         return MNONE;
2035     case CSSValueScroll:
2036         return MSCROLL;
2037     case CSSValueSlide:
2038         return MSLIDE;
2039     case CSSValueAlternate:
2040         return MALTERNATE;
2041     default:
2042         break;
2043     }
2044
2045     ASSERT_NOT_REACHED();
2046     return MNONE;
2047 }
2048
2049 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(RegionFragment e)
2050     : CSSValue(PrimitiveClass)
2051 {
2052     m_primitiveUnitType = CSS_VALUE_ID;
2053     switch (e) {
2054     case AutoRegionFragment:
2055         m_value.valueID = CSSValueAuto;
2056         break;
2057     case BreakRegionFragment:
2058         m_value.valueID = CSSValueBreak;
2059         break;
2060     }
2061 }
2062
2063 template<> inline CSSPrimitiveValue::operator RegionFragment() const
2064 {
2065     ASSERT(isValueID());
2066
2067     switch (m_value.valueID) {
2068     case CSSValueAuto:
2069         return AutoRegionFragment;
2070     case CSSValueBreak:
2071         return BreakRegionFragment;
2072     default:
2073         break;
2074     }
2075
2076     ASSERT_NOT_REACHED();
2077     return AutoRegionFragment;
2078 }
2079
2080 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EMarqueeDirection e)
2081     : CSSValue(PrimitiveClass)
2082 {
2083     m_primitiveUnitType = CSS_VALUE_ID;
2084     switch (e) {
2085     case MFORWARD:
2086         m_value.valueID = CSSValueForwards;
2087         break;
2088     case MBACKWARD:
2089         m_value.valueID = CSSValueBackwards;
2090         break;
2091     case MAUTO:
2092         m_value.valueID = CSSValueAuto;
2093         break;
2094     case MUP:
2095         m_value.valueID = CSSValueUp;
2096         break;
2097     case MDOWN:
2098         m_value.valueID = CSSValueDown;
2099         break;
2100     case MLEFT:
2101         m_value.valueID = CSSValueLeft;
2102         break;
2103     case MRIGHT:
2104         m_value.valueID = CSSValueRight;
2105         break;
2106     }
2107 }
2108
2109 template<> inline CSSPrimitiveValue::operator EMarqueeDirection() const
2110 {
2111     ASSERT(isValueID());
2112
2113     switch (m_value.valueID) {
2114     case CSSValueForwards:
2115         return MFORWARD;
2116     case CSSValueBackwards:
2117         return MBACKWARD;
2118     case CSSValueAuto:
2119         return MAUTO;
2120     case CSSValueAhead:
2121     case CSSValueUp: // We don't support vertical languages, so AHEAD just maps to UP.
2122         return MUP;
2123     case CSSValueReverse:
2124     case CSSValueDown: // REVERSE just maps to DOWN, since we don't do vertical text.
2125         return MDOWN;
2126     case CSSValueLeft:
2127         return MLEFT;
2128     case CSSValueRight:
2129         return MRIGHT;
2130     default:
2131         break;
2132     }
2133
2134     ASSERT_NOT_REACHED();
2135     return MAUTO;
2136 }
2137
2138 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ENBSPMode e)
2139     : CSSValue(PrimitiveClass)
2140 {
2141     m_primitiveUnitType = CSS_VALUE_ID;
2142     switch (e) {
2143     case NBNORMAL:
2144         m_value.valueID = CSSValueNormal;
2145         break;
2146     case SPACE:
2147         m_value.valueID = CSSValueSpace;
2148         break;
2149     }
2150 }
2151
2152 template<> inline CSSPrimitiveValue::operator ENBSPMode() const
2153 {
2154     ASSERT(isValueID());
2155
2156     switch (m_value.valueID) {
2157     case CSSValueSpace:
2158         return SPACE;
2159     case CSSValueNormal:
2160         return NBNORMAL;
2161     default:
2162         break;
2163     }
2164
2165     ASSERT_NOT_REACHED();
2166     return NBNORMAL;
2167 }
2168
2169 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EOverflow e)
2170     : CSSValue(PrimitiveClass)
2171 {
2172     m_primitiveUnitType = CSS_VALUE_ID;
2173     switch (e) {
2174     case OVISIBLE:
2175         m_value.valueID = CSSValueVisible;
2176         break;
2177     case OHIDDEN:
2178         m_value.valueID = CSSValueHidden;
2179         break;
2180     case OSCROLL:
2181         m_value.valueID = CSSValueScroll;
2182         break;
2183     case OAUTO:
2184         m_value.valueID = CSSValueAuto;
2185         break;
2186     case OOVERLAY:
2187         m_value.valueID = CSSValueOverlay;
2188         break;
2189     case OPAGEDX:
2190         m_value.valueID = CSSValueWebkitPagedX;
2191         break;
2192     case OPAGEDY:
2193         m_value.valueID = CSSValueWebkitPagedY;
2194         break;
2195     }
2196 }
2197
2198 template<> inline CSSPrimitiveValue::operator EOverflow() const
2199 {
2200     ASSERT(isValueID());
2201
2202     switch (m_value.valueID) {
2203     case CSSValueVisible:
2204         return OVISIBLE;
2205     case CSSValueHidden:
2206         return OHIDDEN;
2207     case CSSValueScroll:
2208         return OSCROLL;
2209     case CSSValueAuto:
2210         return OAUTO;
2211     case CSSValueOverlay:
2212         return OOVERLAY;
2213     case CSSValueWebkitPagedX:
2214         return OPAGEDX;
2215     case CSSValueWebkitPagedY:
2216         return OPAGEDY;
2217     default:
2218         break;
2219     }
2220
2221     ASSERT_NOT_REACHED();
2222     return OVISIBLE;
2223 }
2224
2225 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(BreakBetween e)
2226     : CSSValue(PrimitiveClass)
2227 {
2228     m_primitiveUnitType = CSS_VALUE_ID;
2229     switch (e) {
2230     case AutoBreakBetween:
2231         m_value.valueID = CSSValueAuto;
2232         break;
2233     case AvoidBreakBetween:
2234         m_value.valueID = CSSValueAvoid;
2235         break;
2236     case AvoidColumnBreakBetween:
2237         m_value.valueID = CSSValueAvoidColumn;
2238         break;
2239     case AvoidPageBreakBetween:
2240         m_value.valueID = CSSValueAvoidPage;
2241         break;
2242     case AvoidRegionBreakBetween:
2243         m_value.valueID = CSSValueAvoidRegion;
2244         break;
2245     case ColumnBreakBetween:
2246         m_value.valueID = CSSValueColumn;
2247         break;
2248     case PageBreakBetween:
2249         m_value.valueID = CSSValuePage;
2250         break;
2251     case RegionBreakBetween:
2252         m_value.valueID = CSSValueRegion;
2253         break;
2254     case LeftPageBreakBetween:
2255         m_value.valueID = CSSValueLeft;
2256         break;
2257     case RightPageBreakBetween:
2258         m_value.valueID = CSSValueRight;
2259         break;
2260     case RectoPageBreakBetween:
2261         m_value.valueID = CSSValueRecto;
2262         break;
2263     case VersoPageBreakBetween:
2264         m_value.valueID = CSSValueVerso;
2265         break;
2266     }
2267 }
2268
2269 template<> inline CSSPrimitiveValue::operator BreakBetween() const
2270 {
2271     ASSERT(isValueID());
2272
2273     switch (m_value.valueID) {
2274     case CSSValueAuto:
2275         return AutoBreakBetween;
2276     case CSSValueAvoid:
2277         return AvoidBreakBetween;
2278     case CSSValueAvoidColumn:
2279         return AvoidColumnBreakBetween;
2280     case CSSValueAvoidPage:
2281         return AvoidPageBreakBetween;
2282     case CSSValueAvoidRegion:
2283         return AvoidRegionBreakBetween;
2284     case CSSValueColumn:
2285         return ColumnBreakBetween;
2286     case CSSValuePage:
2287         return PageBreakBetween;
2288     case CSSValueRegion:
2289         return RegionBreakBetween;
2290     case CSSValueLeft:
2291         return LeftPageBreakBetween;
2292     case CSSValueRight:
2293         return RightPageBreakBetween;
2294     case CSSValueRecto:
2295         return RectoPageBreakBetween;
2296     case CSSValueVerso:
2297         return VersoPageBreakBetween;
2298     default:
2299         break;
2300     }
2301
2302     ASSERT_NOT_REACHED();
2303     return AutoBreakBetween;
2304 }
2305
2306 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(BreakInside e)
2307     : CSSValue(PrimitiveClass)
2308 {
2309     m_primitiveUnitType = CSS_VALUE_ID;
2310     switch (e) {
2311     case AutoBreakInside:
2312         m_value.valueID = CSSValueAuto;
2313         break;
2314     case AvoidBreakInside:
2315         m_value.valueID = CSSValueAvoid;
2316         break;
2317     case AvoidColumnBreakInside:
2318         m_value.valueID = CSSValueAvoidColumn;
2319         break;
2320     case AvoidPageBreakInside:
2321         m_value.valueID = CSSValueAvoidPage;
2322         break;
2323     case AvoidRegionBreakInside:
2324         m_value.valueID = CSSValueAvoidRegion;
2325         break;
2326     }
2327 }
2328
2329 template<> inline CSSPrimitiveValue::operator BreakInside() const
2330 {
2331     ASSERT(isValueID());
2332     
2333     switch (m_value.valueID) {
2334     case CSSValueAuto:
2335         return AutoBreakInside;
2336     case CSSValueAvoid:
2337         return AvoidBreakInside;
2338     case CSSValueAvoidColumn:
2339         return AvoidColumnBreakInside;
2340     case CSSValueAvoidPage:
2341         return AvoidPageBreakInside;
2342     case CSSValueAvoidRegion:
2343         return AvoidRegionBreakInside;
2344     default:
2345         break;
2346     }
2347
2348     ASSERT_NOT_REACHED();
2349     return AutoBreakInside;
2350 }
2351
2352 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EPosition e)
2353     : CSSValue(PrimitiveClass)
2354 {
2355     m_primitiveUnitType = CSS_VALUE_ID;
2356     switch (e) {
2357     case StaticPosition:
2358         m_value.valueID = CSSValueStatic;
2359         break;
2360     case RelativePosition:
2361         m_value.valueID = CSSValueRelative;
2362         break;
2363     case AbsolutePosition:
2364         m_value.valueID = CSSValueAbsolute;
2365         break;
2366     case FixedPosition:
2367         m_value.valueID = CSSValueFixed;
2368         break;
2369     case StickyPosition:
2370         m_value.valueID = CSSValueWebkitSticky;
2371         break;
2372     }
2373 }
2374
2375 template<> inline CSSPrimitiveValue::operator EPosition() const
2376 {
2377     ASSERT(isValueID());
2378
2379     switch (m_value.valueID) {
2380     case CSSValueStatic:
2381         return StaticPosition;
2382     case CSSValueRelative:
2383         return RelativePosition;
2384     case CSSValueAbsolute:
2385         return AbsolutePosition;
2386     case CSSValueFixed:
2387         return FixedPosition;
2388     case CSSValueWebkitSticky:
2389         return StickyPosition;
2390     default:
2391         break;
2392     }
2393
2394     ASSERT_NOT_REACHED();
2395     return StaticPosition;
2396 }
2397
2398 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EResize e)
2399     : CSSValue(PrimitiveClass)
2400 {
2401     m_primitiveUnitType = CSS_VALUE_ID;
2402     switch (e) {
2403     case RESIZE_BOTH:
2404         m_value.valueID = CSSValueBoth;
2405         break;
2406     case RESIZE_HORIZONTAL:
2407         m_value.valueID = CSSValueHorizontal;
2408         break;
2409     case RESIZE_VERTICAL:
2410         m_value.valueID = CSSValueVertical;
2411         break;
2412     case RESIZE_NONE:
2413         m_value.valueID = CSSValueNone;
2414         break;
2415     }
2416 }
2417
2418 template<> inline CSSPrimitiveValue::operator EResize() const
2419 {
2420     ASSERT(isValueID());
2421
2422     switch (m_value.valueID) {
2423     case CSSValueBoth:
2424         return RESIZE_BOTH;
2425     case CSSValueHorizontal:
2426         return RESIZE_HORIZONTAL;
2427     case CSSValueVertical:
2428         return RESIZE_VERTICAL;
2429     case CSSValueAuto:
2430         ASSERT_NOT_REACHED(); // Depends on settings, thus should be handled by the caller.
2431         return RESIZE_NONE;
2432     case CSSValueNone:
2433         return RESIZE_NONE;
2434     default:
2435         break;
2436     }
2437
2438     ASSERT_NOT_REACHED();
2439     return RESIZE_NONE;
2440 }
2441
2442 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETableLayout e)
2443     : CSSValue(PrimitiveClass)
2444 {
2445     m_primitiveUnitType = CSS_VALUE_ID;
2446     switch (e) {
2447     case TAUTO:
2448         m_value.valueID = CSSValueAuto;
2449         break;
2450     case TFIXED:
2451         m_value.valueID = CSSValueFixed;
2452         break;
2453     }
2454 }
2455
2456 template<> inline CSSPrimitiveValue::operator ETableLayout() const
2457 {
2458     ASSERT(isValueID());
2459
2460     switch (m_value.valueID) {
2461     case CSSValueFixed:
2462         return TFIXED;
2463     case CSSValueAuto:
2464         return TAUTO;
2465     default:
2466         break;
2467     }
2468
2469     ASSERT_NOT_REACHED();
2470     return TAUTO;
2471 }
2472
2473 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETextAlign e)
2474     : CSSValue(PrimitiveClass)
2475 {
2476     m_primitiveUnitType = CSS_VALUE_ID;
2477     switch (e) {
2478     case TASTART:
2479         m_value.valueID = CSSValueStart;
2480         break;
2481     case TAEND:
2482         m_value.valueID = CSSValueEnd;
2483         break;
2484     case LEFT:
2485         m_value.valueID = CSSValueLeft;
2486         break;
2487     case RIGHT:
2488         m_value.valueID = CSSValueRight;
2489         break;
2490     case CENTER:
2491         m_value.valueID = CSSValueCenter;
2492         break;
2493     case JUSTIFY:
2494         m_value.valueID = CSSValueJustify;
2495         break;
2496     case WEBKIT_LEFT:
2497         m_value.valueID = CSSValueWebkitLeft;
2498         break;
2499     case WEBKIT_RIGHT:
2500         m_value.valueID = CSSValueWebkitRight;
2501         break;
2502     case WEBKIT_CENTER:
2503         m_value.valueID = CSSValueWebkitCenter;
2504         break;
2505     }
2506 }
2507
2508 template<> inline CSSPrimitiveValue::operator ETextAlign() const
2509 {
2510     ASSERT(isValueID());
2511
2512     switch (m_value.valueID) {
2513     case CSSValueWebkitAuto: // Legacy -webkit-auto. Eqiuvalent to start.
2514     case CSSValueStart:
2515         return TASTART;
2516     case CSSValueEnd:
2517         return TAEND;
2518     default:
2519         return static_cast<ETextAlign>(m_value.valueID - CSSValueLeft);
2520     }
2521 }
2522
2523 #if ENABLE(CSS3_TEXT)
2524 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextAlignLast e)
2525     : CSSValue(PrimitiveClass)
2526 {
2527     m_primitiveUnitType = CSS_VALUE_ID;
2528     switch (e) {
2529     case TextAlignLastStart:
2530         m_value.valueID = CSSValueStart;
2531         break;
2532     case TextAlignLastEnd:
2533         m_value.valueID = CSSValueEnd;
2534         break;
2535     case TextAlignLastLeft:
2536         m_value.valueID = CSSValueLeft;
2537         break;
2538     case TextAlignLastRight:
2539         m_value.valueID = CSSValueRight;
2540         break;
2541     case TextAlignLastCenter:
2542         m_value.valueID = CSSValueCenter;
2543         break;
2544     case TextAlignLastJustify:
2545         m_value.valueID = CSSValueJustify;
2546         break;
2547     case TextAlignLastAuto:
2548         m_value.valueID = CSSValueAuto;
2549         break;
2550     }
2551 }
2552
2553 template<> inline CSSPrimitiveValue::operator TextAlignLast() const
2554 {
2555     ASSERT(isValueID());
2556
2557     switch (m_value.valueID) {
2558     case CSSValueAuto:
2559         return TextAlignLastAuto;
2560     case CSSValueStart:
2561         return TextAlignLastStart;
2562     case CSSValueEnd:
2563         return TextAlignLastEnd;
2564     case CSSValueLeft:
2565         return TextAlignLastLeft;
2566     case CSSValueRight:
2567         return TextAlignLastRight;
2568     case CSSValueCenter:
2569         return TextAlignLastCenter;
2570     case CSSValueJustify:
2571         return TextAlignLastJustify;
2572     default:
2573         break;
2574     }
2575
2576     ASSERT_NOT_REACHED();
2577     return TextAlignLastAuto;
2578 }
2579
2580 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextJustify e)
2581     : CSSValue(PrimitiveClass)
2582 {
2583     m_primitiveUnitType = CSS_VALUE_ID;
2584     switch (e) {
2585     case TextJustifyAuto:
2586         m_value.valueID = CSSValueAuto;
2587         break;
2588     case TextJustifyNone:
2589         m_value.valueID = CSSValueNone;
2590         break;
2591     case TextJustifyInterWord:
2592         m_value.valueID = CSSValueInterWord;
2593         break;
2594     case TextJustifyDistribute:
2595         m_value.valueID = CSSValueDistribute;
2596         break;
2597     }
2598 }
2599
2600 template<> inline CSSPrimitiveValue::operator TextJustify() const
2601 {
2602     ASSERT(isValueID());
2603
2604     switch (m_value.valueID) {
2605     case CSSValueAuto:
2606         return TextJustifyAuto;
2607     case CSSValueNone:
2608         return TextJustifyNone;
2609     case CSSValueInterWord:
2610         return TextJustifyInterWord;
2611     case CSSValueDistribute:
2612         return TextJustifyDistribute;
2613     default:
2614         break;
2615     }
2616
2617     ASSERT_NOT_REACHED();
2618     return TextJustifyAuto;
2619 }
2620 #endif // CSS3_TEXT
2621
2622 template<> inline CSSPrimitiveValue::operator TextDecoration() const
2623 {
2624     ASSERT(isValueID());
2625
2626     switch (m_value.valueID) {
2627     case CSSValueNone:
2628         return TextDecorationNone;
2629     case CSSValueUnderline:
2630         return TextDecorationUnderline;
2631     case CSSValueOverline:
2632         return TextDecorationOverline;
2633     case CSSValueLineThrough:
2634         return TextDecorationLineThrough;
2635     case CSSValueBlink:
2636         return TextDecorationBlink;
2637 #if ENABLE(LETTERPRESS)
2638     case CSSValueWebkitLetterpress:
2639         return TextDecorationLetterpress;
2640 #endif
2641     default:
2642         break;
2643     }
2644
2645     ASSERT_NOT_REACHED();
2646     return TextDecorationNone;
2647 }
2648
2649 template<> inline CSSPrimitiveValue::operator TextDecorationStyle() const
2650 {
2651     ASSERT(isValueID());
2652
2653     switch (m_value.valueID) {
2654     case CSSValueSolid:
2655         return TextDecorationStyleSolid;
2656     case CSSValueDouble:
2657         return TextDecorationStyleDouble;
2658     case CSSValueDotted:
2659         return TextDecorationStyleDotted;
2660     case CSSValueDashed:
2661         return TextDecorationStyleDashed;
2662     case CSSValueWavy:
2663         return TextDecorationStyleWavy;
2664     default:
2665         break;
2666     }
2667
2668     ASSERT_NOT_REACHED();
2669     return TextDecorationStyleSolid;
2670 }
2671
2672 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextUnderlinePosition e)
2673     : CSSValue(PrimitiveClass)
2674 {
2675     m_primitiveUnitType = CSS_VALUE_ID;
2676     switch (e) {
2677     case TextUnderlinePositionAuto:
2678         m_value.valueID = CSSValueAuto;
2679         break;
2680     case TextUnderlinePositionAlphabetic:
2681         m_value.valueID = CSSValueAlphabetic;
2682         break;
2683     case TextUnderlinePositionUnder:
2684         m_value.valueID = CSSValueUnder;
2685         break;
2686     }
2687
2688     // FIXME: Implement support for 'under left' and 'under right' values.
2689 }
2690
2691 template<> inline CSSPrimitiveValue::operator TextUnderlinePosition() const
2692 {
2693     ASSERT(isValueID());
2694
2695     switch (m_value.valueID) {
2696     case CSSValueAuto:
2697         return TextUnderlinePositionAuto;
2698     case CSSValueAlphabetic:
2699         return TextUnderlinePositionAlphabetic;
2700     case CSSValueUnder:
2701         return TextUnderlinePositionUnder;
2702     default:
2703         break;
2704     }
2705
2706     // FIXME: Implement support for 'under left' and 'under right' values.
2707
2708     ASSERT_NOT_REACHED();
2709     return TextUnderlinePositionAuto;
2710 }
2711
2712 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETextSecurity e)
2713     : CSSValue(PrimitiveClass)
2714 {
2715     m_primitiveUnitType = CSS_VALUE_ID;
2716     switch (e) {
2717     case TSNONE:
2718         m_value.valueID = CSSValueNone;
2719         break;
2720     case TSDISC:
2721         m_value.valueID = CSSValueDisc;
2722         break;
2723     case TSCIRCLE:
2724         m_value.valueID = CSSValueCircle;
2725         break;
2726     case TSSQUARE:
2727         m_value.valueID = CSSValueSquare;
2728         break;
2729     }
2730 }
2731
2732 template<> inline CSSPrimitiveValue::operator ETextSecurity() const
2733 {
2734     ASSERT(isValueID());
2735
2736     switch (m_value.valueID) {
2737     case CSSValueNone:
2738         return TSNONE;
2739     case CSSValueDisc:
2740         return TSDISC;
2741     case CSSValueCircle:
2742         return TSCIRCLE;
2743     case CSSValueSquare:
2744         return TSSQUARE;
2745     default:
2746         break;
2747     }
2748
2749     ASSERT_NOT_REACHED();
2750     return TSNONE;
2751 }
2752
2753 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETextTransform e)
2754     : CSSValue(PrimitiveClass)
2755 {
2756     m_primitiveUnitType = CSS_VALUE_ID;
2757     switch (e) {
2758     case CAPITALIZE:
2759         m_value.valueID = CSSValueCapitalize;
2760         break;
2761     case UPPERCASE:
2762         m_value.valueID = CSSValueUppercase;
2763         break;
2764     case LOWERCASE:
2765         m_value.valueID = CSSValueLowercase;
2766         break;
2767     case TTNONE:
2768         m_value.valueID = CSSValueNone;
2769         break;
2770     }
2771 }
2772
2773 template<> inline CSSPrimitiveValue::operator ETextTransform() const
2774 {
2775     ASSERT(isValueID());
2776
2777     switch (m_value.valueID) {
2778     case CSSValueCapitalize:
2779         return CAPITALIZE;
2780     case CSSValueUppercase:
2781         return UPPERCASE;
2782     case CSSValueLowercase:
2783         return LOWERCASE;
2784     case CSSValueNone:
2785         return TTNONE;
2786     default:
2787         break;
2788     }
2789
2790     ASSERT_NOT_REACHED();
2791     return TTNONE;
2792 }
2793
2794 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUnicodeBidi e)
2795     : CSSValue(PrimitiveClass)
2796 {
2797     m_primitiveUnitType = CSS_VALUE_ID;
2798     switch (e) {
2799     case UBNormal:
2800         m_value.valueID = CSSValueNormal;
2801         break;
2802     case Embed:
2803         m_value.valueID = CSSValueEmbed;
2804         break;
2805     case Override:
2806         m_value.valueID = CSSValueBidiOverride;
2807         break;
2808     case Isolate:
2809         m_value.valueID = CSSValueWebkitIsolate;
2810         break;
2811     case IsolateOverride:
2812         m_value.valueID = CSSValueWebkitIsolateOverride;
2813         break;
2814     case Plaintext:
2815         m_value.valueID = CSSValueWebkitPlaintext;
2816         break;
2817     }
2818 }
2819
2820 template<> inline CSSPrimitiveValue::operator EUnicodeBidi() const
2821 {
2822     ASSERT(isValueID());
2823
2824     switch (m_value.valueID) {
2825     case CSSValueNormal:
2826         return UBNormal;
2827     case CSSValueEmbed:
2828         return Embed;
2829     case CSSValueBidiOverride:
2830         return Override;
2831     case CSSValueWebkitIsolate:
2832         return Isolate;
2833     case CSSValueWebkitIsolateOverride:
2834         return IsolateOverride;
2835     case CSSValueWebkitPlaintext:
2836         return Plaintext;
2837     default:
2838         break;
2839     }
2840
2841     ASSERT_NOT_REACHED();
2842     return UBNormal;
2843 }
2844
2845 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUserDrag e)
2846     : CSSValue(PrimitiveClass)
2847 {
2848     m_primitiveUnitType = CSS_VALUE_ID;
2849     switch (e) {
2850     case DRAG_AUTO:
2851         m_value.valueID = CSSValueAuto;
2852         break;
2853     case DRAG_NONE:
2854         m_value.valueID = CSSValueNone;
2855         break;
2856     case DRAG_ELEMENT:
2857         m_value.valueID = CSSValueElement;
2858         break;
2859     default:
2860         break;
2861     }
2862 }
2863
2864 template<> inline CSSPrimitiveValue::operator EUserDrag() const
2865 {
2866     ASSERT(isValueID());
2867
2868     switch (m_value.valueID) {
2869     case CSSValueAuto:
2870         return DRAG_AUTO;
2871     case CSSValueNone:
2872         return DRAG_NONE;
2873     case CSSValueElement:
2874         return DRAG_ELEMENT;
2875     default:
2876         break;
2877     }
2878
2879     ASSERT_NOT_REACHED();
2880     return DRAG_AUTO;
2881 }
2882
2883 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUserModify e)
2884     : CSSValue(PrimitiveClass)
2885 {
2886     m_primitiveUnitType = CSS_VALUE_ID;
2887     switch (e) {
2888     case READ_ONLY:
2889         m_value.valueID = CSSValueReadOnly;
2890         break;
2891     case READ_WRITE:
2892         m_value.valueID = CSSValueReadWrite;
2893         break;
2894     case READ_WRITE_PLAINTEXT_ONLY:
2895         m_value.valueID = CSSValueReadWritePlaintextOnly;
2896         break;
2897     }
2898 }
2899
2900 template<> inline CSSPrimitiveValue::operator EUserModify() const
2901 {
2902     ASSERT(isValueID());
2903
2904     switch (m_value.valueID) {
2905     case CSSValueReadOnly:
2906         return READ_ONLY;
2907     case CSSValueReadWrite:
2908         return READ_WRITE;
2909     case CSSValueReadWritePlaintextOnly:
2910         return READ_WRITE_PLAINTEXT_ONLY;
2911     default:
2912         break;
2913     }
2914
2915     ASSERT_NOT_REACHED();
2916     return READ_ONLY;
2917 }
2918
2919 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUserSelect e)
2920     : CSSValue(PrimitiveClass)
2921 {
2922     m_primitiveUnitType = CSS_VALUE_ID;
2923     switch (e) {
2924     case SELECT_NONE:
2925         m_value.valueID = CSSValueNone;
2926         break;
2927     case SELECT_TEXT:
2928         m_value.valueID = CSSValueText;
2929         break;
2930     case SELECT_ALL:
2931         m_value.valueID = CSSValueAll;
2932         break;
2933     }
2934 }
2935
2936 template<> inline CSSPrimitiveValue::operator EUserSelect() const
2937 {
2938     ASSERT(isValueID());
2939
2940     switch (m_value.valueID) {
2941     case CSSValueAuto:
2942         return SELECT_TEXT;
2943     case CSSValueNone:
2944         return SELECT_NONE;
2945     case CSSValueText:
2946         return SELECT_TEXT;
2947     case CSSValueAll:
2948         return SELECT_ALL;
2949     default:
2950         break;
2951     }
2952
2953     ASSERT_NOT_REACHED();
2954     return SELECT_TEXT;
2955 }
2956
2957 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EVerticalAlign a)
2958     : CSSValue(PrimitiveClass)
2959 {
2960     m_primitiveUnitType = CSS_VALUE_ID;
2961     switch (a) {
2962     case TOP:
2963         m_value.valueID = CSSValueTop;
2964         break;
2965     case BOTTOM:
2966         m_value.valueID = CSSValueBottom;
2967         break;
2968     case MIDDLE:
2969         m_value.valueID = CSSValueMiddle;
2970         break;
2971     case BASELINE:
2972         m_value.valueID = CSSValueBaseline;
2973         break;
2974     case TEXT_BOTTOM:
2975         m_value.valueID = CSSValueTextBottom;
2976         break;
2977     case TEXT_TOP:
2978         m_value.valueID = CSSValueTextTop;
2979         break;
2980     case SUB:
2981         m_value.valueID = CSSValueSub;
2982         break;
2983     case SUPER:
2984         m_value.valueID = CSSValueSuper;
2985         break;
2986     case BASELINE_MIDDLE:
2987         m_value.valueID = CSSValueWebkitBaselineMiddle;
2988         break;
2989     case LENGTH:
2990         m_value.valueID = CSSValueInvalid;
2991     }
2992 }
2993
2994 template<> inline CSSPrimitiveValue::operator EVerticalAlign() const
2995 {
2996     ASSERT(isValueID());
2997
2998     switch (m_value.valueID) {
2999     case CSSValueTop:
3000         return TOP;
3001     case CSSValueBottom:
3002         return BOTTOM;
3003     case CSSValueMiddle:
3004         return MIDDLE;
3005     case CSSValueBaseline:
3006         return BASELINE;
3007     case CSSValueTextBottom:
3008         return TEXT_BOTTOM;
3009     case CSSValueTextTop:
3010         return TEXT_TOP;
3011     case CSSValueSub:
3012         return SUB;
3013     case CSSValueSuper:
3014         return SUPER;
3015     case CSSValueWebkitBaselineMiddle:
3016         return BASELINE_MIDDLE;
3017     default:
3018         break;
3019     }
3020
3021     ASSERT_NOT_REACHED();
3022     return TOP;
3023 }
3024
3025 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EVisibility e)
3026     : CSSValue(PrimitiveClass)
3027 {
3028     m_primitiveUnitType = CSS_VALUE_ID;
3029     switch (e) {
3030     case VISIBLE:
3031         m_value.valueID = CSSValueVisible;
3032         break;
3033     case HIDDEN:
3034         m_value.valueID = CSSValueHidden;
3035         break;
3036     case COLLAPSE:
3037         m_value.valueID = CSSValueCollapse;
3038         break;
3039     }
3040 }
3041
3042 template<> inline CSSPrimitiveValue::operator EVisibility() const
3043 {
3044     ASSERT(isValueID());
3045
3046     switch (m_value.valueID) {
3047     case CSSValueHidden:
3048         return HIDDEN;
3049     case CSSValueVisible:
3050         return VISIBLE;
3051     case CSSValueCollapse:
3052         return COLLAPSE;
3053     default:
3054         break;
3055     }
3056
3057     ASSERT_NOT_REACHED();
3058     return VISIBLE;
3059 }
3060
3061 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EWhiteSpace e)
3062     : CSSValue(PrimitiveClass)
3063 {
3064     m_primitiveUnitType = CSS_VALUE_ID;
3065     switch (e) {
3066     case NORMAL:
3067         m_value.valueID = CSSValueNormal;
3068         break;
3069     case PRE:
3070         m_value.valueID = CSSValuePre;
3071         break;
3072     case PRE_WRAP:
3073         m_value.valueID = CSSValuePreWrap;
3074         break;
3075     case PRE_LINE:
3076         m_value.valueID = CSSValuePreLine;
3077         break;
3078     case NOWRAP:
3079         m_value.valueID = CSSValueNowrap;
3080         break;
3081     case KHTML_NOWRAP:
3082         m_value.valueID = CSSValueWebkitNowrap;
3083         break;
3084     }
3085 }
3086
3087 template<> inline CSSPrimitiveValue::operator EWhiteSpace() const
3088 {
3089     ASSERT(isValueID());
3090
3091     switch (m_value.valueID) {
3092     case CSSValueWebkitNowrap:
3093         return KHTML_NOWRAP;
3094     case CSSValueNowrap:
3095         return NOWRAP;
3096     case CSSValuePre:
3097         return PRE;
3098     case CSSValuePreWrap:
3099         return PRE_WRAP;
3100     case CSSValuePreLine:
3101         return PRE_LINE;
3102     case CSSValueNormal:
3103         return NORMAL;
3104     default:
3105         break;
3106     }
3107
3108     ASSERT_NOT_REACHED();
3109     return NORMAL;
3110 }
3111
3112 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EWordBreak e)
3113     : CSSValue(PrimitiveClass)
3114 {
3115     m_primitiveUnitType = CSS_VALUE_ID;
3116     switch (e) {
3117     case NormalWordBreak:
3118         m_value.valueID = CSSValueNormal;
3119         break;
3120     case BreakAllWordBreak:
3121         m_value.valueID = CSSValueBreakAll;
3122         break;
3123     case KeepAllWordBreak:
3124         m_value.valueID = CSSValueKeepAll;
3125         break;
3126     case BreakWordBreak:
3127         m_value.valueID = CSSValueBreakWord;
3128         break;
3129     }
3130 }
3131
3132 template<> inline CSSPrimitiveValue::operator EWordBreak() const
3133 {
3134     ASSERT(isValueID());
3135
3136     switch (m_value.valueID) {
3137     case CSSValueBreakAll:
3138         return BreakAllWordBreak;
3139     case CSSValueKeepAll:
3140         return KeepAllWordBreak;
3141     case CSSValueBreakWord:
3142         return BreakWordBreak;
3143     case CSSValueNormal:
3144         return NormalWordBreak;
3145     default:
3146         break;
3147     }
3148
3149     ASSERT_NOT_REACHED();
3150     return NormalWordBreak;
3151 }
3152
3153 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EOverflowWrap e)
3154     : CSSValue(PrimitiveClass)
3155 {
3156     m_primitiveUnitType = CSS_VALUE_ID;
3157     switch (e) {
3158     case NormalOverflowWrap:
3159         m_value.valueID = CSSValueNormal;
3160         break;
3161     case BreakOverflowWrap:
3162         m_value.valueID = CSSValueBreakWord;
3163         break;
3164     }
3165 }
3166
3167 template<> inline CSSPrimitiveValue::operator EOverflowWrap() const
3168 {
3169     ASSERT(isValueID());
3170
3171     switch (m_value.valueID) {
3172     case CSSValueBreakWord:
3173         return BreakOverflowWrap;
3174     case CSSValueNormal:
3175         return NormalOverflowWrap;
3176     default:
3177         break;
3178     }
3179
3180     ASSERT_NOT_REACHED();
3181     return NormalOverflowWrap;
3182 }
3183
3184 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextDirection e)
3185     : CSSValue(PrimitiveClass)
3186 {
3187     m_primitiveUnitType = CSS_VALUE_ID;
3188     switch (e) {
3189     case LTR:
3190         m_value.valueID = CSSValueLtr;
3191         break;
3192     case RTL:
3193         m_value.valueID = CSSValueRtl;
3194         break;
3195     }
3196 }
3197
3198 template<> inline CSSPrimitiveValue::operator TextDirection() const
3199 {
3200     ASSERT(isValueID());
3201
3202     switch (m_value.valueID) {
3203     case CSSValueLtr:
3204         return LTR;
3205     case CSSValueRtl:
3206         return RTL;
3207     default:
3208         break;
3209     }
3210
3211     ASSERT_NOT_REACHED();
3212     return LTR;
3213 }
3214
3215 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(WritingMode e)
3216     : CSSValue(PrimitiveClass)
3217 {
3218     m_primitiveUnitType = CSS_VALUE_ID;
3219     switch (e) {
3220     case TopToBottomWritingMode:
3221         m_value.valueID = CSSValueHorizontalTb;
3222         break;
3223     case RightToLeftWritingMode:
3224         m_value.valueID = CSSValueVerticalRl;
3225         break;
3226     case LeftToRightWritingMode:
3227         m_value.valueID = CSSValueVerticalLr;
3228         break;
3229     case BottomToTopWritingMode:
3230         m_value.valueID = CSSValueHorizontalBt;
3231         break;
3232     }
3233 }
3234
3235 template<> inline CSSPrimitiveValue::operator WritingMode() const
3236 {
3237     ASSERT(isValueID());
3238
3239     switch (m_value.valueID) {
3240     case CSSValueHorizontalTb:
3241     case CSSValueLrTb:
3242     case CSSValueRl:
3243     case CSSValueRlTb:
3244         return TopToBottomWritingMode;
3245     case CSSValueVerticalRl:
3246     case CSSValueTb:
3247     case CSSValueTbRl:
3248         return RightToLeftWritingMode;
3249     case CSSValueVerticalLr:
3250         return LeftToRightWritingMode;
3251     case CSSValueHorizontalBt:
3252         return BottomToTopWritingMode;
3253     default:
3254         break;
3255     }
3256
3257     ASSERT_NOT_REACHED();
3258     return TopToBottomWritingMode;
3259 }
3260
3261 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextCombine e)
3262     : CSSValue(PrimitiveClass)
3263 {
3264     m_primitiveUnitType = CSS_VALUE_ID;
3265     switch (e) {
3266     case TextCombineNone:
3267         m_value.valueID = CSSValueNone;
3268         break;
3269     case TextCombineHorizontal:
3270         m_value.valueID = CSSValueHorizontal;
3271         break;
3272     }
3273 }
3274
3275 template<> inline CSSPrimitiveValue::operator TextCombine() const
3276 {
3277     ASSERT(isValueID());
3278
3279     switch (m_value.valueID) {
3280     case CSSValueNone:
3281         return TextCombineNone;
3282     case CSSValueHorizontal:
3283         return TextCombineHorizontal;
3284     default:
3285         break;
3286     }
3287
3288     ASSERT_NOT_REACHED();
3289     return TextCombineNone;
3290 }
3291
3292 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(RubyPosition position)
3293     : CSSValue(PrimitiveClass)
3294 {
3295     m_primitiveUnitType = CSS_VALUE_ID;
3296     switch (position) {
3297     case RubyPositionBefore:
3298         m_value.valueID = CSSValueBefore;
3299         break;
3300     case RubyPositionAfter:
3301         m_value.valueID = CSSValueAfter;
3302         break;
3303     case RubyPositionInterCharacter:
3304         m_value.valueID = CSSValueInterCharacter;
3305         break;
3306     }
3307 }
3308
3309 template<> inline CSSPrimitiveValue::operator RubyPosition() const
3310 {
3311     ASSERT(isValueID());
3312
3313     switch (m_value.valueID) {
3314     case CSSValueBefore:
3315         return RubyPositionBefore;
3316     case CSSValueAfter:
3317         return RubyPositionAfter;
3318     case CSSValueInterCharacter:
3319         return RubyPositionInterCharacter;
3320     default:
3321         break;
3322     }
3323
3324     ASSERT_NOT_REACHED();
3325     return RubyPositionBefore;
3326 }
3327
3328 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextOverflow overflow)
3329     : CSSValue(PrimitiveClass)
3330 {
3331     m_primitiveUnitType = CSS_VALUE_ID;
3332     switch (overflow) {
3333     case TextOverflowClip:
3334         m_value.valueID = CSSValueClip;
3335         break;
3336     case TextOverflowEllipsis:
3337         m_value.valueID = CSSValueEllipsis;
3338         break;
3339     }
3340 }
3341
3342 template<> inline CSSPrimitiveValue::operator TextOverflow() const
3343 {
3344     ASSERT(isValueID());
3345
3346     switch (m_value.valueID) {
3347     case CSSValueClip:
3348         return TextOverflowClip;
3349     case CSSValueEllipsis:
3350         return TextOverflowEllipsis;
3351     default:
3352         break;
3353     }
3354
3355     ASSERT_NOT_REACHED();
3356     return TextOverflowClip;
3357 }
3358
3359 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextEmphasisFill fill)
3360     : CSSValue(PrimitiveClass)
3361 {
3362     m_primitiveUnitType = CSS_VALUE_ID;
3363     switch (fill) {
3364     case TextEmphasisFillFilled:
3365         m_value.valueID = CSSValueFilled;
3366         break;
3367     case TextEmphasisFillOpen:
3368         m_value.valueID = CSSValueOpen;
3369         break;
3370     }
3371 }
3372
3373 template<> inline CSSPrimitiveValue::operator TextEmphasisFill() const
3374 {
3375     ASSERT(isValueID());
3376
3377     switch (m_value.valueID) {
3378     case CSSValueFilled:
3379         return TextEmphasisFillFilled;
3380     case CSSValueOpen:
3381         return TextEmphasisFillOpen;
3382     default:
3383         break;
3384     }
3385
3386     ASSERT_NOT_REACHED();
3387     return TextEmphasisFillFilled;
3388 }
3389
3390 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextEmphasisMark mark)
3391     : CSSValue(PrimitiveClass)
3392 {
3393     m_primitiveUnitType = CSS_VALUE_ID;
3394     switch (mark) {
3395     case TextEmphasisMarkDot:
3396         m_value.valueID = CSSValueDot;
3397         break;
3398     case TextEmphasisMarkCircle:
3399         m_value.valueID = CSSValueCircle;
3400         break;
3401     case TextEmphasisMarkDoubleCircle:
3402         m_value.valueID = CSSValueDoubleCircle;
3403         break;
3404     case TextEmphasisMarkTriangle:
3405         m_value.valueID = CSSValueTriangle;
3406         break;
3407     case TextEmphasisMarkSesame:
3408         m_value.valueID = CSSValueSesame;
3409         break;
3410     case TextEmphasisMarkNone:
3411     case TextEmphasisMarkAuto:
3412     case TextEmphasisMarkCustom:
3413         ASSERT_NOT_REACHED();
3414         m_value.valueID = CSSValueNone;
3415         break;
3416     }
3417 }
3418
3419 template<> inline CSSPrimitiveValue::operator TextEmphasisMark() const
3420 {
3421     ASSERT(isValueID());
3422
3423     switch (m_value.valueID) {
3424     case CSSValueNone:
3425         return TextEmphasisMarkNone;
3426     case CSSValueDot:
3427         return TextEmphasisMarkDot;
3428     case CSSValueCircle:
3429         return TextEmphasisMarkCircle;
3430     case CSSValueDoubleCircle:
3431         return TextEmphasisMarkDoubleCircle;
3432     case CSSValueTriangle:
3433         return TextEmphasisMarkTriangle;
3434     case CSSValueSesame:
3435         return TextEmphasisMarkSesame;
3436     default:
3437         break;
3438     }
3439
3440     ASSERT_NOT_REACHED();
3441     return TextEmphasisMarkNone;
3442 }
3443
3444 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextOrientation e)
3445     : CSSValue(PrimitiveClass)
3446 {
3447     m_primitiveUnitType = CSS_VALUE_ID;
3448     switch (e) {
3449     case TextOrientation::Sideways:
3450         m_value.valueID = CSSValueSideways;
3451         break;
3452     case TextOrientation::Mixed:
3453         m_value.valueID = CSSValueMixed;
3454         break;
3455     case TextOrientation::Upright:
3456         m_value.valueID = CSSValueUpright;
3457         break;
3458     }
3459 }
3460
3461 template<> inline CSSPrimitiveValue::operator TextOrientation() const
3462 {
3463     ASSERT(isValueID());
3464
3465     switch (m_value.valueID) {
3466     case CSSValueSideways:
3467         return TextOrientation::Sideways;
3468     case CSSValueSidewaysRight:
3469         return TextOrientation::Sideways;
3470     case CSSValueVerticalRight:
3471         return TextOrientation::Mixed;
3472     case CSSValueMixed:
3473         return TextOrientation::Mixed;
3474     case CSSValueUpright:
3475         return TextOrientation::Upright;
3476     default:
3477         break;
3478     }
3479
3480     ASSERT_NOT_REACHED();
3481     return TextOrientation::Mixed;
3482 }
3483
3484 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EPointerEvents e)
3485     : CSSValue(PrimitiveClass)
3486 {
3487     m_primitiveUnitType = CSS_VALUE_ID;
3488     switch (e) {
3489     case PE_NONE:
3490         m_value.valueID = CSSValueNone;
3491         break;
3492     case PE_STROKE:
3493         m_value.valueID = CSSValueStroke;
3494         break;
3495     case PE_FILL:
3496         m_value.valueID = CSSValueFill;
3497         break;
3498     case PE_PAINTED:
3499         m_value.valueID = CSSValuePainted;
3500         break;
3501     case PE_VISIBLE:
3502         m_value.valueID = CSSValueVisible;
3503         break;
3504     case PE_VISIBLE_STROKE:
3505         m_value.valueID = CSSValueVisibleStroke;
3506         break;
3507     case PE_VISIBLE_FILL:
3508         m_value.valueID = CSSValueVisibleFill;
3509         break;
3510     case PE_VISIBLE_PAINTED:
3511         m_value.valueID = CSSValueVisiblePainted;
3512         break;
3513     case PE_AUTO:
3514         m_value.valueID = CSSValueAuto;
3515         break;
3516     case PE_ALL:
3517         m_value.valueID = CSSValueAll;
3518         break;
3519     }
3520 }
3521
3522 template<> inline CSSPrimitiveValue::operator EPointerEvents() const
3523 {
3524     ASSERT(isValueID());
3525
3526     switch (m_value.valueID) {
3527     case CSSValueAll:
3528         return PE_ALL;
3529     case CSSValueAuto:
3530         return PE_AUTO;
3531     case CSSValueNone:
3532         return PE_NONE;
3533     case CSSValueVisiblePainted:
3534         return PE_VISIBLE_PAINTED;
3535     case CSSValueVisibleFill:
3536         return PE_VISIBLE_FILL;
3537     case CSSValueVisibleStroke:
3538         return PE_VISIBLE_STROKE;
3539     case CSSValueVisible:
3540         return PE_VISIBLE;
3541     case CSSValuePainted:
3542         return PE_PAINTED;
3543     case CSSValueFill:
3544         return PE_FILL;
3545     case CSSValueStroke:
3546         return PE_STROKE;
3547     default:
3548         break;
3549     }
3550
3551     ASSERT_NOT_REACHED();
3552     return PE_ALL;
3553 }
3554
3555 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(Kerning kerning)
3556     : CSSValue(PrimitiveClass)
3557 {
3558     m_primitiveUnitType = CSS_VALUE_ID;
3559     switch (kerning) {
3560     case Kerning::Auto:
3561         m_value.valueID = CSSValueAuto;
3562         return;
3563     case Kerning::Normal:
3564         m_value.valueID = CSSValueNormal;
3565         return;
3566     case Kerning::NoShift:
3567         m_value.valueID = CSSValueNone;
3568         return;
3569     }
3570
3571     ASSERT_NOT_REACHED();
3572     m_value.valueID = CSSValueAuto;
3573 }
3574
3575 template<> inline CSSPrimitiveValue::operator Kerning() const
3576 {
3577     ASSERT(isValueID());
3578
3579     switch (m_value.valueID) {
3580     case CSSValueAuto:
3581         return Kerning::Auto;
3582     case CSSValueNormal:
3583         return Kerning::Normal;
3584     case CSSValueNone:
3585         return Kerning::NoShift;
3586     default:
3587         break;
3588     }
3589
3590     ASSERT_NOT_REACHED();
3591     return Kerning::Auto;
3592 }
3593
3594 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ObjectFit fit)
3595     : CSSValue(PrimitiveClass)
3596 {
3597     m_primitiveUnitType = CSS_VALUE_ID;
3598     switch (fit) {
3599     case ObjectFitFill:
3600         m_value.valueID = CSSValueFill;
3601         break;
3602     case ObjectFitContain:
3603         m_value.valueID = CSSValueContain;
3604         break;
3605     case ObjectFitCover:
3606         m_value.valueID = CSSValueCover;
3607         break;
3608     case ObjectFitNone:
3609         m_value.valueID = CSSValueNone;
3610         break;
3611     case ObjectFitScaleDown:
3612         m_value.valueID = CSSValueScaleDown;
3613         break;
3614     }
3615 }
3616
3617 template<> inline CSSPrimitiveValue::operator ObjectFit() const
3618 {
3619     ASSERT(isValueID());
3620
3621     switch (m_value.valueID) {
3622     case CSSValueFill:
3623         return ObjectFitFill;
3624     case CSSValueContain:
3625         return ObjectFitContain;
3626     case CSSValueCover:
3627         return ObjectFitCover;
3628     case CSSValueNone:
3629         return ObjectFitNone;
3630     case CSSValueScaleDown:
3631         return ObjectFitScaleDown;
3632     default:
3633         ASSERT_NOT_REACHED();
3634         return ObjectFitFill;
3635     }
3636 }
3637
3638 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontSmoothingMode smoothing)
3639     : CSSValue(PrimitiveClass)
3640 {
3641     m_primitiveUnitType = CSS_VALUE_ID;
3642     switch (smoothing) {
3643     case AutoSmoothing:
3644         m_value.valueID = CSSValueAuto;
3645         return;
3646     case NoSmoothing:
3647         m_value.valueID = CSSValueNone;
3648         return;
3649     case Antialiased:
3650         m_value.valueID = CSSValueAntialiased;
3651         return;
3652     case SubpixelAntialiased:
3653         m_value.valueID = CSSValueSubpixelAntialiased;
3654         return;
3655     }
3656
3657     ASSERT_NOT_REACHED();
3658     m_value.valueID = CSSValueAuto;
3659 }
3660
3661 template<> inline CSSPrimitiveValue::operator FontSmoothingMode() const
3662 {
3663     ASSERT(isValueID());
3664
3665     switch (m_value.valueID) {
3666     case CSSValueAuto:
3667         return AutoSmoothing;
3668     case CSSValueNone:
3669         return NoSmoothing;
3670     case CSSValueAntialiased:
3671         return Antialiased;
3672     case CSSValueSubpixelAntialiased:
3673         return SubpixelAntialiased;
3674     default:
3675         break;
3676     }
3677
3678     ASSERT_NOT_REACHED();
3679     return AutoSmoothing;
3680 }
3681
3682 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontSmallCaps smallCaps)
3683     : CSSValue(PrimitiveClass)
3684 {
3685     m_primitiveUnitType = CSS_VALUE_ID;
3686     switch (smallCaps) {
3687     case FontSmallCapsOff:
3688         m_value.valueID = CSSValueNormal;
3689         return;
3690     case FontSmallCapsOn:
3691         m_value.valueID = CSSValueSmallCaps;
3692         return;
3693     }
3694
3695     ASSERT_NOT_REACHED();
3696     m_value.valueID = CSSValueNormal;
3697 }
3698
3699 template<> inline CSSPrimitiveValue::operator FontSmallCaps() const
3700 {
3701     ASSERT(isValueID());
3702
3703     switch (m_value.valueID) {
3704     case CSSValueSmallCaps:
3705         return FontSmallCapsOn;
3706     case CSSValueNormal:
3707         return FontSmallCapsOff;
3708     default:
3709         break;
3710     }
3711     ASSERT_NOT_REACHED();
3712     return FontSmallCapsOff;
3713 }
3714
3715 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextRenderingMode e)
3716     : CSSValue(PrimitiveClass)
3717 {
3718     m_primitiveUnitType = CSS_VALUE_ID;
3719     switch (e) {
3720     case AutoTextRendering:
3721         m_value.valueID = CSSValueAuto;
3722         break;
3723     case OptimizeSpeed:
3724         m_value.valueID = CSSValueOptimizeSpeed;
3725         break;
3726     case OptimizeLegibility:
3727         m_value.valueID = CSSValueOptimizeLegibility;
3728         break;
3729     case GeometricPrecision:
3730         m_value.valueID = CSSValueGeometricPrecision;
3731         break;
3732     }
3733 }
3734
3735 template<> inline CSSPrimitiveValue::operator TextRenderingMode() const
3736 {
3737     ASSERT(isValueID());
3738
3739     switch (m_value.valueID) {
3740     case CSSValueAuto:
3741         return AutoTextRendering;
3742     case CSSValueOptimizeSpeed:
3743         return OptimizeSpeed;
3744     case CSSValueOptimizeLegibility:
3745         return OptimizeLegibility;
3746     case CSSValueGeometricPrecision:
3747         return GeometricPrecision;
3748     default:
3749         break;
3750     }
3751
3752     ASSERT_NOT_REACHED();
3753     return AutoTextRendering;
3754 }
3755
3756 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(Hyphens hyphens)
3757     : CSSValue(PrimitiveClass)
3758 {
3759     m_primitiveUnitType = CSS_VALUE_ID;
3760     switch (hyphens) {
3761     case HyphensNone:
3762         m_value.valueID = CSSValueNone;
3763         break;
3764     case HyphensManual:
3765         m_value.valueID = CSSValueManual;
3766         break;
3767     case HyphensAuto:
3768         m_value.valueID = CSSValueAuto;
3769         break;
3770     }
3771 }
3772
3773 template<> inline CSSPrimitiveValue::operator Hyphens() const
3774 {
3775     ASSERT(isValueID());
3776
3777     switch (m_value.valueID) {
3778     case CSSValueNone:
3779         return HyphensNone;
3780     case CSSValueManual:
3781         return HyphensManual;
3782     case CSSValueAuto:
3783         return HyphensAuto;
3784     default:
3785         break;
3786     }
3787
3788     ASSERT_NOT_REACHED();
3789     return HyphensAuto;
3790 }
3791
3792 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineSnap gridSnap)
3793     : CSSValue(PrimitiveClass)
3794 {
3795     m_primitiveUnitType = CSS_VALUE_ID;
3796     switch (gridSnap) {
3797     case LineSnapNone:
3798         m_value.valueID = CSSValueNone;
3799         break;
3800     case LineSnapBaseline:
3801         m_value.valueID = CSSValueBaseline;
3802         break;
3803     case LineSnapContain:
3804         m_value.valueID = CSSValueContain;
3805         break;
3806     }
3807 }
3808
3809 template<> inline CSSPrimitiveValue::operator LineSnap() const
3810 {
3811     ASSERT(isValueID());
3812
3813     switch (m_value.valueID) {
3814     case CSSValueNone:
3815         return LineSnapNone;
3816     case CSSValueBaseline:
3817         return LineSnapBaseline;
3818     case CSSValueContain:
3819         return LineSnapContain;
3820     default:
3821         break;
3822     }
3823
3824     ASSERT_NOT_REACHED();
3825     return LineSnapNone;
3826 }
3827
3828 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineAlign lineAlign)
3829     : CSSValue(PrimitiveClass)
3830 {
3831     m_primitiveUnitType = CSS_VALUE_ID;
3832     switch (lineAlign) {
3833     case LineAlignNone:
3834         m_value.valueID = CSSValueNone;
3835         break;
3836     case LineAlignEdges:
3837         m_value.valueID = CSSValueEdges;
3838         break;
3839     }
3840 }
3841
3842 template<> inline CSSPrimitiveValue::operator LineAlign() const
3843 {
3844     ASSERT(isValueID());
3845
3846     switch (m_value.valueID) {
3847     case CSSValueNone:
3848         return LineAlignNone;
3849     case CSSValueEdges:
3850         return LineAlignEdges;
3851     default:
3852         break;
3853     }
3854
3855     ASSERT_NOT_REACHED();
3856     return LineAlignNone;
3857 }
3858
3859 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ESpeak e)
3860     : CSSValue(PrimitiveClass)
3861 {
3862     m_primitiveUnitType = CSS_VALUE_ID;
3863     switch (e) {
3864     case SpeakNone:
3865         m_value.valueID = CSSValueNone;
3866         break;
3867     case SpeakNormal:
3868         m_value.valueID = CSSValueNormal;
3869         break;
3870     case SpeakSpellOut:
3871         m_value.valueID = CSSValueSpellOut;
3872         break;
3873     case SpeakDigits:
3874         m_value.valueID = CSSValueDigits;
3875         break;
3876     case SpeakLiteralPunctuation:
3877         m_value.valueID = CSSValueLiteralPunctuation;
3878         break;
3879     case SpeakNoPunctuation:
3880         m_value.valueID = CSSValueNoPunctuation;
3881         break;
3882     }
3883 }
3884
3885 template<> inline CSSPrimitiveValue::operator Order() const
3886 {
3887     ASSERT(isValueID());
3888
3889     switch (m_value.valueID) {
3890     case CSSValueLogical:
3891         return LogicalOrder;
3892     case CSSValueVisual:
3893         return VisualOrder;
3894     default:
3895         break;
3896     }
3897
3898     ASSERT_NOT_REACHED();
3899     return LogicalOrder;
3900 }
3901
3902 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(Order e)
3903     : CSSValue(PrimitiveClass)
3904 {
3905     m_primitiveUnitType = CSS_VALUE_ID;
3906     switch (e) {
3907     case LogicalOrder:
3908         m_value.valueID = CSSValueLogical;
3909         break;
3910     case VisualOrder:
3911         m_value.valueID = CSSValueVisual;
3912         break;
3913     }
3914 }
3915
3916 template<> inline CSSPrimitiveValue::operator ESpeak() const
3917 {
3918     ASSERT(isValueID());
3919
3920     switch (m_value.valueID) {
3921     case CSSValueNone:
3922         return SpeakNone;
3923     case CSSValueNormal:
3924         return SpeakNormal;
3925     case CSSValueSpellOut:
3926         return SpeakSpellOut;
3927     case CSSValueDigits:
3928         return SpeakDigits;
3929     case CSSValueLiteralPunctuation:
3930         return SpeakLiteralPunctuation;
3931     case CSSValueNoPunctuation:
3932         return SpeakNoPunctuation;
3933     default:
3934         break;
3935     }
3936
3937     ASSERT_NOT_REACHED();
3938     return SpeakNormal;
3939 }
3940
3941 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(BlendMode blendMode)
3942     : CSSValue(PrimitiveClass)
3943 {
3944     m_primitiveUnitType = CSS_VALUE_ID;
3945     switch (blendMode) {
3946     case BlendModeNormal:
3947         m_value.valueID = CSSValueNormal;
3948         break;
3949     case BlendModeMultiply:
3950         m_value.valueID = CSSValueMultiply;
3951         break;
3952     case BlendModeScreen:
3953         m_value.valueID = CSSValueScreen;
3954         break;
3955     case BlendModeOverlay:
3956         m_value.valueID = CSSValueOverlay;
3957         break;
3958     case BlendModeDarken:
3959         m_value.valueID = CSSValueDarken;
3960         break;
3961     case BlendModeLighten:
3962         m_value.valueID = CSSValueLighten;
3963         break;
3964     case BlendModeColorDodge:
3965         m_value.valueID = CSSValueColorDodge;
3966         break;
3967     case BlendModeColorBurn:
3968         m_value.valueID = CSSValueColorBurn;
3969         break;
3970     case BlendModeHardLight:
3971         m_value.valueID = CSSValueHardLight;
3972         break;
3973     case BlendModeSoftLight:
3974         m_value.valueID = CSSValueSoftLight;
3975         break;
3976     case BlendModeDifference:
3977         m_value.valueID = CSSValueDifference;
3978         break;
3979     case BlendModeExclusion:
3980         m_value.valueID = CSSValueExclusion;
3981         break;
3982     case BlendModeHue:
3983         m_value.valueID = CSSValueHue;
3984         break;
3985     case BlendModeSaturation:
3986         m_value.valueID = CSSValueSaturation;
3987         break;
3988     case BlendModeColor:
3989         m_value.valueID = CSSValueColor;
3990         break;
3991     case BlendModeLuminosity:
3992         m_value.valueID = CSSValueLuminosity;
3993         break;
3994     case BlendModePlusDarker:
3995         m_value.valueID = CSSValuePlusDarker;
3996         break;
3997     case BlendModePlusLighter:
3998         m_value.valueID = CSSValuePlusLighter;
3999         break;
4000     }
4001 }
4002
4003 template<> inline CSSPrimitiveValue::operator BlendMode() const
4004 {
4005     ASSERT(isValueID());
4006
4007     switch (m_value.valueID) {
4008     case CSSValueNormal:
4009         return BlendModeNormal;
4010     case CSSValueMultiply:
4011         return BlendModeMultiply;
4012     case CSSValueScreen:
4013         return BlendModeScreen;
4014     case CSSValueOverlay:
4015         return BlendModeOverlay;
4016     case CSSValueDarken:
4017         return BlendModeDarken;
4018     case CSSValueLighten:
4019         return BlendModeLighten;
4020     case CSSValueColorDodge:
4021         return BlendModeColorDodge;
4022     case CSSValueColorBurn:
4023         return BlendModeColorBurn;
4024     case CSSValueHardLight:
4025         return BlendModeHardLight;
4026     case CSSValueSoftLight:
4027         return BlendModeSoftLight;
4028     case CSSValueDifference:
4029         return BlendModeDifference;
4030     case CSSValueExclusion:
4031         return BlendModeExclusion;
4032     case CSSValueHue:
4033         return BlendModeHue;
4034     case CSSValueSaturation:
4035         return BlendModeSaturation;
4036     case CSSValueColor:
4037         return BlendModeColor;
4038     case CSSValueLuminosity:
4039         return BlendModeLuminosity;
4040     case CSSValuePlusDarker:
4041         return BlendModePlusDarker;
4042     case CSSValuePlusLighter:
4043         return BlendModePlusLighter;
4044     default:
4045         break;
4046     }
4047
4048     ASSERT_NOT_REACHED();
4049     return BlendModeNormal;
4050 }
4051
4052 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(Isolation isolation)
4053     : CSSValue(PrimitiveClass)
4054 {
4055     m_primitiveUnitType = CSS_VALUE_ID;
4056     switch (isolation) {
4057     case IsolationAuto:
4058         m_value.valueID = CSSValueAuto;
4059         break;
4060     case IsolationIsolate:
4061         m_value.valueID = CSSValueIsolate;
4062         break;
4063     default:
4064         ASSERT_NOT_REACHED();
4065     }
4066 }
4067
4068 template<> inline CSSPrimitiveValue::operator Isolation() const
4069 {
4070     ASSERT(isValueID());
4071     switch (m_value.valueID) {
4072     case CSSValueAuto:
4073         return IsolationAuto;
4074     case CSSValueIsolate:
4075         return IsolationIsolate;
4076     default:
4077         break;
4078     }
4079
4080     ASSERT_NOT_REACHED();
4081     return IsolationAuto;
4082 }
4083
4084 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineCap e)
4085     : CSSValue(PrimitiveClass)
4086 {
4087     m_primitiveUnitType = CSS_VALUE_ID;
4088     switch (e) {
4089     case ButtCap:
4090         m_value.valueID = CSSValueButt;
4091         break;
4092     case RoundCap:
4093         m_value.valueID = CSSValueRound;
4094         break;
4095     case SquareCap:
4096         m_value.valueID = CSSValueSquare;
4097         break;
4098     }
4099 }
4100
4101 template<> inline CSSPrimitiveValue::operator LineCap() const
4102 {
4103     ASSERT(isValueID());
4104
4105     switch (m_value.valueID) {
4106     case CSSValueButt:
4107         return ButtCap;
4108     case CSSValueRound:
4109         return RoundCap;
4110     case CSSValueSquare:
4111         return SquareCap;
4112     default:
4113         break;
4114     }
4115
4116     ASSERT_NOT_REACHED();
4117     return ButtCap;
4118 }
4119
4120 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineJoin e)
4121     : CSSValue(PrimitiveClass)
4122 {
4123     m_primitiveUnitType = CSS_VALUE_ID;
4124     switch (e) {
4125     case MiterJoin:
4126         m_value.valueID = CSSValueMiter;
4127         break;
4128     case RoundJoin:
4129         m_value.valueID = CSSValueRound;
4130         break;
4131     case BevelJoin:
4132         m_value.valueID = CSSValueBevel;
4133         break;
4134     }
4135 }
4136
4137 template<> inline CSSPrimitiveValue::operator LineJoin() const
4138 {
4139     ASSERT(isValueID());
4140
4141     switch (m_value.valueID) {
4142     case CSSValueMiter:
4143         return MiterJoin;
4144     case CSSValueRound:
4145         return RoundJoin;
4146     case CSSValueBevel:
4147         return BevelJoin;
4148     default:
4149         break;
4150     }
4151
4152     ASSERT_NOT_REACHED();
4153     return MiterJoin;
4154 }
4155
4156 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(WindRule e)
4157     : CSSValue(PrimitiveClass)
4158 {
4159     m_primitiveUnitType = CSS_VALUE_ID;
4160     switch (e) {
4161     case RULE_NONZERO:
4162         m_value.valueID = CSSValueNonzero;
4163         break;
4164     case RULE_EVENODD:
4165         m_value.valueID = CSSValueEvenodd;
4166         break;
4167     }
4168 }
4169
4170 template<> inline CSSPrimitiveValue::operator WindRule() const
4171 {
4172     ASSERT(isValueID());
4173
4174     switch (m_value.valueID) {
4175     case CSSValueNonzero:
4176         return RULE_NONZERO;
4177     case CSSValueEvenodd:
4178         return RULE_EVENODD;
4179     default:
4180         break;
4181     }
4182
4183     ASSERT_NOT_REACHED();
4184     return RULE_NONZERO;
4185 }
4186
4187
4188 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EAlignmentBaseline e)
4189     : CSSValue(PrimitiveClass)
4190 {
4191     m_primitiveUnitType = CSS_VALUE_ID;
4192     switch (e) {
4193     case AB_AUTO:
4194         m_value.valueID = CSSValueAuto;
4195         break;
4196     case AB_BASELINE:
4197         m_value.valueID = CSSValueBaseline;
4198         break;
4199     case AB_BEFORE_EDGE:
4200         m_value.valueID = CSSValueBeforeEdge;
4201         break;
4202     case AB_TEXT_BEFORE_EDGE:
4203         m_value.valueID = CSSValueTextBeforeEdge;
4204         break;
4205     case AB_MIDDLE:
4206         m_value.valueID = CSSValueMiddle;
4207         break;
4208     case AB_CENTRAL:
4209         m_value.valueID = CSSValueCentral;
4210         break;
4211     case AB_AFTER_EDGE:
4212         m_value.valueID = CSSValueAfterEdge;
4213         break;
4214     case AB_TEXT_AFTER_EDGE:
4215         m_value.valueID = CSSValueTextAfterEdge;
4216         break;
4217     case AB_IDEOGRAPHIC:
4218         m_value.valueID = CSSValueIdeographic;
4219         break;
4220     case AB_ALPHABETIC:
4221         m_value.valueID = CSSValueAlphabetic;
4222         break;
4223     case AB_HANGING:
4224         m_value.valueID = CSSValueHanging;
4225         break;
4226     case AB_MATHEMATICAL:
4227         m_value.valueID = CSSValueMathematical;
4228         break;
4229     }
4230 }
4231
4232 template<> inline CSSPrimitiveValue::operator EAlignmentBaseline() const
4233 {
4234     ASSERT(isValueID());
4235
4236     switch (m_value.valueID) {
4237     case CSSValueAuto:
4238         return AB_AUTO;
4239     case CSSValueBaseline:
4240         return AB_BASELINE;
4241     case CSSValueBeforeEdge:
4242         return AB_BEFORE_EDGE;
4243     case CSSValueTextBeforeEdge:
4244         return AB_TEXT_BEFORE_EDGE;
4245     case CSSValueMiddle:
4246         return AB_MIDDLE;
4247     case CSSValueCentral:
4248         return AB_CENTRAL;
4249     case CSSValueAfterEdge:
4250         return AB_AFTER_EDGE;
4251     case CSSValueTextAfterEdge:
4252         return AB_TEXT_AFTER_EDGE;
4253 &