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