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