214f5e5cbc7c18f85a72410fb098c9c658d3a140
[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     }
610 }
611
612 template<> inline CSSPrimitiveValue::operator ControlPart() const
613 {
614     ASSERT(isValueID());
615
616     if (m_value.valueID == CSSValueNone)
617         return NoControlPart;
618     return ControlPart(m_value.valueID - CSSValueCheckbox + 1);
619 }
620
621 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBackfaceVisibility e)
622     : CSSValue(PrimitiveClass)
623 {
624     m_primitiveUnitType = CSS_VALUE_ID;
625     switch (e) {
626     case BackfaceVisibilityVisible:
627         m_value.valueID = CSSValueVisible;
628         break;
629     case BackfaceVisibilityHidden:
630         m_value.valueID = CSSValueHidden;
631         break;
632     }
633 }
634
635 template<> inline CSSPrimitiveValue::operator EBackfaceVisibility() const
636 {
637     ASSERT(isValueID());
638
639     switch (m_value.valueID) {
640     case CSSValueVisible:
641         return BackfaceVisibilityVisible;
642     case CSSValueHidden:
643         return BackfaceVisibilityHidden;
644     default:
645         break;
646     }
647
648     ASSERT_NOT_REACHED();
649     return BackfaceVisibilityHidden;
650 }
651
652
653 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFillAttachment e)
654     : CSSValue(PrimitiveClass)
655 {
656     m_primitiveUnitType = CSS_VALUE_ID;
657     switch (e) {
658     case ScrollBackgroundAttachment:
659         m_value.valueID = CSSValueScroll;
660         break;
661     case LocalBackgroundAttachment:
662         m_value.valueID = CSSValueLocal;
663         break;
664     case FixedBackgroundAttachment:
665         m_value.valueID = CSSValueFixed;
666         break;
667     }
668 }
669
670 template<> inline CSSPrimitiveValue::operator EFillAttachment() const
671 {
672     ASSERT(isValueID());
673
674     switch (m_value.valueID) {
675     case CSSValueScroll:
676         return ScrollBackgroundAttachment;
677     case CSSValueLocal:
678         return LocalBackgroundAttachment;
679     case CSSValueFixed:
680         return FixedBackgroundAttachment;
681     default:
682         break;
683     }
684
685     ASSERT_NOT_REACHED();
686     return ScrollBackgroundAttachment;
687 }
688
689 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFillBox e)
690     : CSSValue(PrimitiveClass)
691 {
692     m_primitiveUnitType = CSS_VALUE_ID;
693     switch (e) {
694     case BorderFillBox:
695         m_value.valueID = CSSValueBorderBox;
696         break;
697     case PaddingFillBox:
698         m_value.valueID = CSSValuePaddingBox;
699         break;
700     case ContentFillBox:
701         m_value.valueID = CSSValueContentBox;
702         break;
703     case TextFillBox:
704         m_value.valueID = CSSValueText;
705         break;
706     }
707 }
708
709 template<> inline CSSPrimitiveValue::operator EFillBox() const
710 {
711     ASSERT(isValueID());
712
713     switch (m_value.valueID) {
714     case CSSValueBorder:
715     case CSSValueBorderBox:
716         return BorderFillBox;
717     case CSSValuePadding:
718     case CSSValuePaddingBox:
719         return PaddingFillBox;
720     case CSSValueContent:
721     case CSSValueContentBox:
722         return ContentFillBox;
723     case CSSValueText:
724     case CSSValueWebkitText:
725         return TextFillBox;
726     default:
727         break;
728     }
729
730     ASSERT_NOT_REACHED();
731     return BorderFillBox;
732 }
733
734 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFillRepeat e)
735     : CSSValue(PrimitiveClass)
736 {
737     m_primitiveUnitType = CSS_VALUE_ID;
738     switch (e) {
739     case RepeatFill:
740         m_value.valueID = CSSValueRepeat;
741         break;
742     case NoRepeatFill:
743         m_value.valueID = CSSValueNoRepeat;
744         break;
745     case RoundFill:
746         m_value.valueID = CSSValueRound;
747         break;
748     case SpaceFill:
749         m_value.valueID = CSSValueSpace;
750         break;
751     }
752 }
753
754 template<> inline CSSPrimitiveValue::operator EFillRepeat() const
755 {
756     ASSERT(isValueID());
757
758     switch (m_value.valueID) {
759     case CSSValueRepeat:
760         return RepeatFill;
761     case CSSValueNoRepeat:
762         return NoRepeatFill;
763     case CSSValueRound:
764         return RoundFill;
765     case CSSValueSpace:
766         return SpaceFill;
767     default:
768         break;
769     }
770
771     ASSERT_NOT_REACHED();
772     return RepeatFill;
773 }
774
775 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxPack e)
776     : CSSValue(PrimitiveClass)
777 {
778     m_primitiveUnitType = CSS_VALUE_ID;
779     switch (e) {
780     case Start:
781         m_value.valueID = CSSValueStart;
782         break;
783     case Center:
784         m_value.valueID = CSSValueCenter;
785         break;
786     case End:
787         m_value.valueID = CSSValueEnd;
788         break;
789     case Justify:
790         m_value.valueID = CSSValueJustify;
791         break;
792     }
793 }
794
795 template<> inline CSSPrimitiveValue::operator EBoxPack() const
796 {
797     ASSERT(isValueID());
798
799     switch (m_value.valueID) {
800     case CSSValueStart:
801         return Start;
802     case CSSValueEnd:
803         return End;
804     case CSSValueCenter:
805         return Center;
806     case CSSValueJustify:
807         return Justify;
808     default:
809         break;
810     }
811
812     ASSERT_NOT_REACHED();
813     return Justify;
814 }
815
816 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxAlignment e)
817     : CSSValue(PrimitiveClass)
818 {
819     m_primitiveUnitType = CSS_VALUE_ID;
820     switch (e) {
821     case BSTRETCH:
822         m_value.valueID = CSSValueStretch;
823         break;
824     case BSTART:
825         m_value.valueID = CSSValueStart;
826         break;
827     case BCENTER:
828         m_value.valueID = CSSValueCenter;
829         break;
830     case BEND:
831         m_value.valueID = CSSValueEnd;
832         break;
833     case BBASELINE:
834         m_value.valueID = CSSValueBaseline;
835         break;
836     }
837 }
838
839 template<> inline CSSPrimitiveValue::operator EBoxAlignment() const
840 {
841     ASSERT(isValueID());
842
843     switch (m_value.valueID) {
844     case CSSValueStretch:
845         return BSTRETCH;
846     case CSSValueStart:
847         return BSTART;
848     case CSSValueEnd:
849         return BEND;
850     case CSSValueCenter:
851         return BCENTER;
852     case CSSValueBaseline:
853         return BBASELINE;
854     default:
855         break;
856     }
857
858     ASSERT_NOT_REACHED();
859     return BSTRETCH;
860 }
861
862 #if ENABLE(CSS_BOX_DECORATION_BREAK)
863 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxDecorationBreak e)
864     : CSSValue(PrimitiveClass)
865 {
866     m_primitiveUnitType = CSS_VALUE_ID;
867     switch (e) {
868     case DSLICE:
869         m_value.valueID = CSSValueSlice;
870         break;
871     case DCLONE:
872         m_value.valueID = CSSValueClone;
873         break;
874     }
875 }
876
877 template<> inline CSSPrimitiveValue::operator EBoxDecorationBreak() const
878 {
879     ASSERT(isValueID());
880
881     switch (m_value.valueID) {
882     case CSSValueSlice:
883         return DSLICE;
884     case CSSValueClone:
885         return DCLONE;
886     default:
887         break;
888     }
889
890     ASSERT_NOT_REACHED();
891     return DSLICE;
892 }
893 #endif
894
895 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(BackgroundEdgeOrigin e)
896     : CSSValue(PrimitiveClass)
897 {
898     m_primitiveUnitType = CSS_VALUE_ID;
899     switch (e) {
900     case TopEdge:
901         m_value.valueID = CSSValueTop;
902         break;
903     case RightEdge:
904         m_value.valueID = CSSValueRight;
905         break;
906     case BottomEdge:
907         m_value.valueID = CSSValueBottom;
908         break;
909     case LeftEdge:
910         m_value.valueID = CSSValueLeft;
911         break;
912     }
913 }
914
915 template<> inline CSSPrimitiveValue::operator BackgroundEdgeOrigin() const
916 {
917     ASSERT(isValueID());
918
919     switch (m_value.valueID) {
920     case CSSValueTop:
921         return TopEdge;
922     case CSSValueRight:
923         return RightEdge;
924     case CSSValueBottom:
925         return BottomEdge;
926     case CSSValueLeft:
927         return LeftEdge;
928     default:
929         break;
930     }
931
932     ASSERT_NOT_REACHED();
933     return TopEdge;
934 }
935
936 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxSizing e)
937     : CSSValue(PrimitiveClass)
938 {
939     m_primitiveUnitType = CSS_VALUE_ID;
940     switch (e) {
941     case BORDER_BOX:
942         m_value.valueID = CSSValueBorderBox;
943         break;
944     case CONTENT_BOX:
945         m_value.valueID = CSSValueContentBox;
946         break;
947     }
948 }
949
950 template<> inline CSSPrimitiveValue::operator EBoxSizing() const
951 {
952     ASSERT(isValueID());
953
954     switch (m_value.valueID) {
955     case CSSValueBorderBox:
956         return BORDER_BOX;
957     case CSSValueContentBox:
958         return CONTENT_BOX;
959     default:
960         break;
961     }
962
963     ASSERT_NOT_REACHED();
964     return BORDER_BOX;
965 }
966
967 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxDirection e)
968     : CSSValue(PrimitiveClass)
969 {
970     m_primitiveUnitType = CSS_VALUE_ID;
971     switch (e) {
972     case BNORMAL:
973         m_value.valueID = CSSValueNormal;
974         break;
975     case BREVERSE:
976         m_value.valueID = CSSValueReverse;
977         break;
978     }
979 }
980
981 template<> inline CSSPrimitiveValue::operator EBoxDirection() const
982 {
983     ASSERT(isValueID());
984
985     switch (m_value.valueID) {
986     case CSSValueNormal:
987         return BNORMAL;
988     case CSSValueReverse:
989         return BREVERSE;
990     default:
991         break;
992     }
993
994     ASSERT_NOT_REACHED();
995     return BNORMAL;
996 }
997
998 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxLines e)
999     : CSSValue(PrimitiveClass)
1000 {
1001     m_primitiveUnitType = CSS_VALUE_ID;
1002     switch (e) {
1003     case SINGLE:
1004         m_value.valueID = CSSValueSingle;
1005         break;
1006     case MULTIPLE:
1007         m_value.valueID = CSSValueMultiple;
1008         break;
1009     }
1010 }
1011
1012 template<> inline CSSPrimitiveValue::operator EBoxLines() const
1013 {
1014     ASSERT(isValueID());
1015
1016     switch (m_value.valueID) {
1017     case CSSValueSingle:
1018         return SINGLE;
1019     case CSSValueMultiple:
1020         return MULTIPLE;
1021     default:
1022         break;
1023     }
1024
1025     ASSERT_NOT_REACHED();
1026     return SINGLE;
1027 }
1028
1029 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxOrient e)
1030     : CSSValue(PrimitiveClass)
1031 {
1032     m_primitiveUnitType = CSS_VALUE_ID;
1033     switch (e) {
1034     case HORIZONTAL:
1035         m_value.valueID = CSSValueHorizontal;
1036         break;
1037     case VERTICAL:
1038         m_value.valueID = CSSValueVertical;
1039         break;
1040     }
1041 }
1042
1043 template<> inline CSSPrimitiveValue::operator EBoxOrient() const
1044 {
1045     ASSERT(isValueID());
1046
1047     switch (m_value.valueID) {
1048     case CSSValueHorizontal:
1049     case CSSValueInlineAxis:
1050         return HORIZONTAL;
1051     case CSSValueVertical:
1052     case CSSValueBlockAxis:
1053         return VERTICAL;
1054     default:
1055         break;
1056     }
1057
1058     ASSERT_NOT_REACHED();
1059     return HORIZONTAL;
1060 }
1061
1062 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ECaptionSide e)
1063     : CSSValue(PrimitiveClass)
1064 {
1065     m_primitiveUnitType = CSS_VALUE_ID;
1066     switch (e) {
1067     case CAPLEFT:
1068         m_value.valueID = CSSValueLeft;
1069         break;
1070     case CAPRIGHT:
1071         m_value.valueID = CSSValueRight;
1072         break;
1073     case CAPTOP:
1074         m_value.valueID = CSSValueTop;
1075         break;
1076     case CAPBOTTOM:
1077         m_value.valueID = CSSValueBottom;
1078         break;
1079     }
1080 }
1081
1082 template<> inline CSSPrimitiveValue::operator ECaptionSide() const
1083 {
1084     ASSERT(isValueID());
1085
1086     switch (m_value.valueID) {
1087     case CSSValueLeft:
1088         return CAPLEFT;
1089     case CSSValueRight:
1090         return CAPRIGHT;
1091     case CSSValueTop:
1092         return CAPTOP;
1093     case CSSValueBottom:
1094         return CAPBOTTOM;
1095     default:
1096         break;
1097     }
1098
1099     ASSERT_NOT_REACHED();
1100     return CAPTOP;
1101 }
1102
1103 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EClear e)
1104     : CSSValue(PrimitiveClass)
1105 {
1106     m_primitiveUnitType = CSS_VALUE_ID;
1107     switch (e) {
1108     case CNONE:
1109         m_value.valueID = CSSValueNone;
1110         break;
1111     case CLEFT:
1112         m_value.valueID = CSSValueLeft;
1113         break;
1114     case CRIGHT:
1115         m_value.valueID = CSSValueRight;
1116         break;
1117     case CBOTH:
1118         m_value.valueID = CSSValueBoth;
1119         break;
1120     }
1121 }
1122
1123 template<> inline CSSPrimitiveValue::operator EClear() const
1124 {
1125     ASSERT(isValueID());
1126
1127     switch (m_value.valueID) {
1128     case CSSValueNone:
1129         return CNONE;
1130     case CSSValueLeft:
1131         return CLEFT;
1132     case CSSValueRight:
1133         return CRIGHT;
1134     case CSSValueBoth:
1135         return CBOTH;
1136     default:
1137         break;
1138     }
1139
1140     ASSERT_NOT_REACHED();
1141     return CNONE;
1142 }
1143
1144 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ECursor e)
1145     : CSSValue(PrimitiveClass)
1146 {
1147     m_primitiveUnitType = CSS_VALUE_ID;
1148     switch (e) {
1149     case CURSOR_AUTO:
1150         m_value.valueID = CSSValueAuto;
1151         break;
1152     case CURSOR_CROSS:
1153         m_value.valueID = CSSValueCrosshair;
1154         break;
1155     case CURSOR_DEFAULT:
1156         m_value.valueID = CSSValueDefault;
1157         break;
1158     case CURSOR_POINTER:
1159         m_value.valueID = CSSValuePointer;
1160         break;
1161     case CURSOR_MOVE:
1162         m_value.valueID = CSSValueMove;
1163         break;
1164     case CURSOR_CELL:
1165         m_value.valueID = CSSValueCell;
1166         break;
1167     case CURSOR_VERTICAL_TEXT:
1168         m_value.valueID = CSSValueVerticalText;
1169         break;
1170     case CURSOR_CONTEXT_MENU:
1171         m_value.valueID = CSSValueContextMenu;
1172         break;
1173     case CURSOR_ALIAS:
1174         m_value.valueID = CSSValueAlias;
1175         break;
1176     case CURSOR_COPY:
1177         m_value.valueID = CSSValueCopy;
1178         break;
1179     case CURSOR_NONE:
1180         m_value.valueID = CSSValueNone;
1181         break;
1182     case CURSOR_PROGRESS:
1183         m_value.valueID = CSSValueProgress;
1184         break;
1185     case CURSOR_NO_DROP:
1186         m_value.valueID = CSSValueNoDrop;
1187         break;
1188     case CURSOR_NOT_ALLOWED:
1189         m_value.valueID = CSSValueNotAllowed;
1190         break;
1191     case CURSOR_WEBKIT_ZOOM_IN:
1192         m_value.valueID = CSSValueWebkitZoomIn;
1193         break;
1194     case CURSOR_WEBKIT_ZOOM_OUT:
1195         m_value.valueID = CSSValueWebkitZoomOut;
1196         break;
1197     case CURSOR_E_RESIZE:
1198         m_value.valueID = CSSValueEResize;
1199         break;
1200     case CURSOR_NE_RESIZE:
1201         m_value.valueID = CSSValueNeResize;
1202         break;
1203     case CURSOR_NW_RESIZE:
1204         m_value.valueID = CSSValueNwResize;
1205         break;
1206     case CURSOR_N_RESIZE:
1207         m_value.valueID = CSSValueNResize;
1208         break;
1209     case CURSOR_SE_RESIZE:
1210         m_value.valueID = CSSValueSeResize;
1211         break;
1212     case CURSOR_SW_RESIZE:
1213         m_value.valueID = CSSValueSwResize;
1214         break;
1215     case CURSOR_S_RESIZE:
1216         m_value.valueID = CSSValueSResize;
1217         break;
1218     case CURSOR_W_RESIZE:
1219         m_value.valueID = CSSValueWResize;
1220         break;
1221     case CURSOR_EW_RESIZE:
1222         m_value.valueID = CSSValueEwResize;
1223         break;
1224     case CURSOR_NS_RESIZE:
1225         m_value.valueID = CSSValueNsResize;
1226         break;
1227     case CURSOR_NESW_RESIZE:
1228         m_value.valueID = CSSValueNeswResize;
1229         break;
1230     case CURSOR_NWSE_RESIZE:
1231         m_value.valueID = CSSValueNwseResize;
1232         break;
1233     case CURSOR_COL_RESIZE:
1234         m_value.valueID = CSSValueColResize;
1235         break;
1236     case CURSOR_ROW_RESIZE:
1237         m_value.valueID = CSSValueRowResize;
1238         break;
1239     case CURSOR_TEXT:
1240         m_value.valueID = CSSValueText;
1241         break;
1242     case CURSOR_WAIT:
1243         m_value.valueID = CSSValueWait;
1244         break;
1245     case CURSOR_HELP:
1246         m_value.valueID = CSSValueHelp;
1247         break;
1248     case CURSOR_ALL_SCROLL:
1249         m_value.valueID = CSSValueAllScroll;
1250         break;
1251     case CURSOR_WEBKIT_GRAB:
1252         m_value.valueID = CSSValueWebkitGrab;
1253         break;
1254     case CURSOR_WEBKIT_GRABBING:
1255         m_value.valueID = CSSValueWebkitGrabbing;
1256         break;
1257     }
1258 }
1259
1260 template<> inline CSSPrimitiveValue::operator ECursor() const
1261 {
1262     ASSERT(isValueID());
1263
1264     if (m_value.valueID == CSSValueCopy)
1265         return CURSOR_COPY;
1266     if (m_value.valueID == CSSValueNone)
1267         return CURSOR_NONE;
1268     return static_cast<ECursor>(m_value.valueID - CSSValueAuto);
1269 }
1270
1271
1272 #if ENABLE(CURSOR_VISIBILITY)
1273 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(CursorVisibility e)
1274     : CSSValue(PrimitiveClass)
1275 {
1276     m_primitiveUnitType = CSS_VALUE_ID;
1277     switch (e) {
1278     case CursorVisibilityAuto:
1279         m_value.valueID = CSSValueAuto;
1280         break;
1281     case CursorVisibilityAutoHide:
1282         m_value.valueID = CSSValueAutoHide;
1283         break;
1284     }
1285 }
1286
1287 template<> inline CSSPrimitiveValue::operator CursorVisibility() const
1288 {
1289     ASSERT(isValueID());
1290
1291     if (m_value.valueID == CSSValueAuto)
1292         return CursorVisibilityAuto;
1293     if (m_value.valueID == CSSValueAutoHide)
1294         return CursorVisibilityAutoHide;
1295
1296     ASSERT_NOT_REACHED();
1297     return CursorVisibilityAuto;
1298 }
1299 #endif
1300
1301 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EDisplay e)
1302     : CSSValue(PrimitiveClass)
1303 {
1304     m_primitiveUnitType = CSS_VALUE_ID;
1305     switch (e) {
1306     case INLINE:
1307         m_value.valueID = CSSValueInline;
1308         break;
1309     case BLOCK:
1310         m_value.valueID = CSSValueBlock;
1311         break;
1312     case LIST_ITEM:
1313         m_value.valueID = CSSValueListItem;
1314         break;
1315     case COMPACT:
1316         m_value.valueID = CSSValueCompact;
1317         break;
1318     case INLINE_BLOCK:
1319         m_value.valueID = CSSValueInlineBlock;
1320         break;
1321     case TABLE:
1322         m_value.valueID = CSSValueTable;
1323         break;
1324     case INLINE_TABLE:
1325         m_value.valueID = CSSValueInlineTable;
1326         break;
1327     case TABLE_ROW_GROUP:
1328         m_value.valueID = CSSValueTableRowGroup;
1329         break;
1330     case TABLE_HEADER_GROUP:
1331         m_value.valueID = CSSValueTableHeaderGroup;
1332         break;
1333     case TABLE_FOOTER_GROUP:
1334         m_value.valueID = CSSValueTableFooterGroup;
1335         break;
1336     case TABLE_ROW:
1337         m_value.valueID = CSSValueTableRow;
1338         break;
1339     case TABLE_COLUMN_GROUP:
1340         m_value.valueID = CSSValueTableColumnGroup;
1341         break;
1342     case TABLE_COLUMN:
1343         m_value.valueID = CSSValueTableColumn;
1344         break;
1345     case TABLE_CELL:
1346         m_value.valueID = CSSValueTableCell;
1347         break;
1348     case TABLE_CAPTION:
1349         m_value.valueID = CSSValueTableCaption;
1350         break;
1351     case BOX:
1352         m_value.valueID = CSSValueWebkitBox;
1353         break;
1354     case INLINE_BOX:
1355         m_value.valueID = CSSValueWebkitInlineBox;
1356         break;
1357     case FLEX:
1358         m_value.valueID = CSSValueWebkitFlex;
1359         break;
1360     case INLINE_FLEX:
1361         m_value.valueID = CSSValueWebkitInlineFlex;
1362         break;
1363 #if ENABLE(CSS_GRID_LAYOUT)
1364     case GRID:
1365         m_value.valueID = CSSValueWebkitGrid;
1366         break;
1367     case INLINE_GRID:
1368         m_value.valueID = CSSValueWebkitInlineGrid;
1369         break;
1370 #endif
1371     case NONE:
1372         m_value.valueID = CSSValueNone;
1373         break;
1374     }
1375 }
1376
1377 template<> inline CSSPrimitiveValue::operator EDisplay() const
1378 {
1379     ASSERT(isValueID());
1380
1381     if (m_value.valueID == CSSValueNone)
1382         return NONE;
1383
1384     EDisplay display = static_cast<EDisplay>(m_value.valueID - CSSValueInline);
1385     ASSERT(display >= INLINE && display <= NONE);
1386     return display;
1387 }
1388
1389 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EEmptyCell e)
1390     : CSSValue(PrimitiveClass)
1391 {
1392     m_primitiveUnitType = CSS_VALUE_ID;
1393     switch (e) {
1394     case SHOW:
1395         m_value.valueID = CSSValueShow;
1396         break;
1397     case HIDE:
1398         m_value.valueID = CSSValueHide;
1399         break;
1400     }
1401 }
1402
1403 template<> inline CSSPrimitiveValue::operator EEmptyCell() const
1404 {
1405     ASSERT(isValueID());
1406
1407     switch (m_value.valueID) {
1408     case CSSValueShow:
1409         return SHOW;
1410     case CSSValueHide:
1411         return HIDE;
1412     default:
1413         break;
1414     }
1415
1416     ASSERT_NOT_REACHED();
1417     return SHOW;
1418 }
1419
1420 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EAlignItems e)
1421     : CSSValue(PrimitiveClass)
1422 {
1423     m_primitiveUnitType = CSS_VALUE_ID;
1424     switch (e) {
1425     case AlignAuto:
1426         m_value.valueID = CSSValueAuto;
1427         break;
1428     case AlignFlexStart:
1429         m_value.valueID = CSSValueFlexStart;
1430         break;
1431     case AlignFlexEnd:
1432         m_value.valueID = CSSValueFlexEnd;
1433         break;
1434     case AlignCenter:
1435         m_value.valueID = CSSValueCenter;
1436         break;
1437     case AlignStretch:
1438         m_value.valueID = CSSValueStretch;
1439         break;
1440     case AlignBaseline:
1441         m_value.valueID = CSSValueBaseline;
1442         break;
1443     }
1444 }
1445
1446 template<> inline CSSPrimitiveValue::operator EAlignItems() const
1447 {
1448     ASSERT(isValueID());
1449
1450     switch (m_value.valueID) {
1451     case CSSValueAuto:
1452         return AlignAuto;
1453     case CSSValueFlexStart:
1454         return AlignFlexStart;
1455     case CSSValueFlexEnd:
1456         return AlignFlexEnd;
1457     case CSSValueCenter:
1458         return AlignCenter;
1459     case CSSValueStretch:
1460         return AlignStretch;
1461     case CSSValueBaseline:
1462         return AlignBaseline;
1463     default:
1464         break;
1465     }
1466
1467     ASSERT_NOT_REACHED();
1468     return AlignFlexStart;
1469 }
1470
1471 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EJustifyContent e)
1472     : CSSValue(PrimitiveClass)
1473 {
1474     m_primitiveUnitType = CSS_VALUE_ID;
1475     switch (e) {
1476     case JustifyFlexStart:
1477         m_value.valueID = CSSValueFlexStart;
1478         break;
1479     case JustifyFlexEnd:
1480         m_value.valueID = CSSValueFlexEnd;
1481         break;
1482     case JustifyCenter:
1483         m_value.valueID = CSSValueCenter;
1484         break;
1485     case JustifySpaceBetween:
1486         m_value.valueID = CSSValueSpaceBetween;
1487         break;
1488     case JustifySpaceAround:
1489         m_value.valueID = CSSValueSpaceAround;
1490         break;
1491     }
1492 }
1493
1494 template<> inline CSSPrimitiveValue::operator EJustifyContent() const
1495 {
1496     ASSERT(isValueID());
1497
1498     switch (m_value.valueID) {
1499     case CSSValueFlexStart:
1500         return JustifyFlexStart;
1501     case CSSValueFlexEnd:
1502         return JustifyFlexEnd;
1503     case CSSValueCenter:
1504         return JustifyCenter;
1505     case CSSValueSpaceBetween:
1506         return JustifySpaceBetween;
1507     case CSSValueSpaceAround:
1508         return JustifySpaceAround;
1509     default:
1510         break;
1511     }
1512
1513     ASSERT_NOT_REACHED();
1514     return JustifyFlexStart;
1515 }
1516
1517 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFlexDirection e)
1518     : CSSValue(PrimitiveClass)
1519 {
1520     m_primitiveUnitType = CSS_VALUE_ID;
1521     switch (e) {
1522     case FlowRow:
1523         m_value.valueID = CSSValueRow;
1524         break;
1525     case FlowRowReverse:
1526         m_value.valueID = CSSValueRowReverse;
1527         break;
1528     case FlowColumn:
1529         m_value.valueID = CSSValueColumn;
1530         break;
1531     case FlowColumnReverse:
1532         m_value.valueID = CSSValueColumnReverse;
1533         break;
1534     }
1535 }
1536
1537 template<> inline CSSPrimitiveValue::operator EFlexDirection() const
1538 {
1539     ASSERT(isValueID());
1540
1541     switch (m_value.valueID) {
1542     case CSSValueRow:
1543         return FlowRow;
1544     case CSSValueRowReverse:
1545         return FlowRowReverse;
1546     case CSSValueColumn:
1547         return FlowColumn;
1548     case CSSValueColumnReverse:
1549         return FlowColumnReverse;
1550     default:
1551         break;
1552     }
1553
1554     ASSERT_NOT_REACHED();
1555     return FlowRow;
1556 }
1557
1558 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EAlignContent e)
1559     : CSSValue(PrimitiveClass)
1560 {
1561     m_primitiveUnitType = CSS_VALUE_ID;
1562     switch (e) {
1563     case AlignContentFlexStart:
1564         m_value.valueID = CSSValueFlexStart;
1565         break;
1566     case AlignContentFlexEnd:
1567         m_value.valueID = CSSValueFlexEnd;
1568         break;
1569     case AlignContentCenter:
1570         m_value.valueID = CSSValueCenter;
1571         break;
1572     case AlignContentSpaceBetween:
1573         m_value.valueID = CSSValueSpaceBetween;
1574         break;
1575     case AlignContentSpaceAround:
1576         m_value.valueID = CSSValueSpaceAround;
1577         break;
1578     case AlignContentStretch:
1579         m_value.valueID = CSSValueStretch;
1580         break;
1581     }
1582 }
1583
1584 template<> inline CSSPrimitiveValue::operator EAlignContent() const
1585 {
1586     ASSERT(isValueID());
1587
1588     switch (m_value.valueID) {
1589     case CSSValueFlexStart:
1590         return AlignContentFlexStart;
1591     case CSSValueFlexEnd:
1592         return AlignContentFlexEnd;
1593     case CSSValueCenter:
1594         return AlignContentCenter;
1595     case CSSValueSpaceBetween:
1596         return AlignContentSpaceBetween;
1597     case CSSValueSpaceAround:
1598         return AlignContentSpaceAround;
1599     case CSSValueStretch:
1600         return AlignContentStretch;
1601     default:
1602         break;
1603     }
1604
1605     ASSERT_NOT_REACHED();
1606     return AlignContentStretch;
1607 }
1608
1609 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFlexWrap e)
1610     : CSSValue(PrimitiveClass)
1611 {
1612     m_primitiveUnitType = CSS_VALUE_ID;
1613     switch (e) {
1614     case FlexNoWrap:
1615         m_value.valueID = CSSValueNowrap;
1616         break;
1617     case FlexWrap:
1618         m_value.valueID = CSSValueWrap;
1619         break;
1620     case FlexWrapReverse:
1621         m_value.valueID = CSSValueWrapReverse;
1622         break;
1623     }
1624 }
1625
1626 template<> inline CSSPrimitiveValue::operator EFlexWrap() const
1627 {
1628     ASSERT(isValueID());
1629
1630     switch (m_value.valueID) {
1631     case CSSValueNowrap:
1632         return FlexNoWrap;
1633     case CSSValueWrap:
1634         return FlexWrap;
1635     case CSSValueWrapReverse:
1636         return FlexWrapReverse;
1637     default:
1638         break;
1639     }
1640
1641     ASSERT_NOT_REACHED();
1642     return FlexNoWrap;
1643 }
1644
1645 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFloat e)
1646     : CSSValue(PrimitiveClass)
1647 {
1648     m_primitiveUnitType = CSS_VALUE_ID;
1649     switch (e) {
1650     case NoFloat:
1651         m_value.valueID = CSSValueNone;
1652         break;
1653     case LeftFloat:
1654         m_value.valueID = CSSValueLeft;
1655         break;
1656     case RightFloat:
1657         m_value.valueID = CSSValueRight;
1658         break;
1659     }
1660 }
1661
1662 template<> inline CSSPrimitiveValue::operator EFloat() const
1663 {
1664     ASSERT(isValueID());
1665
1666     switch (m_value.valueID) {
1667     case CSSValueLeft:
1668         return LeftFloat;
1669     case CSSValueRight:
1670         return RightFloat;
1671     case CSSValueNone:
1672     case CSSValueCenter: // Non-standard CSS value.
1673         return NoFloat;
1674     default:
1675         break;
1676     }
1677
1678     ASSERT_NOT_REACHED();
1679     return NoFloat;
1680 }
1681
1682 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineBreak e)
1683     : CSSValue(PrimitiveClass)
1684 {
1685     m_primitiveUnitType = CSS_VALUE_ID;
1686     switch (e) {
1687     case LineBreakAuto:
1688         m_value.valueID = CSSValueAuto;
1689         break;
1690     case LineBreakLoose:
1691         m_value.valueID = CSSValueLoose;
1692         break;
1693     case LineBreakNormal:
1694         m_value.valueID = CSSValueNormal;
1695         break;
1696     case LineBreakStrict:
1697         m_value.valueID = CSSValueStrict;
1698         break;
1699     case LineBreakAfterWhiteSpace:
1700         m_value.valueID = CSSValueAfterWhiteSpace;
1701         break;
1702     }
1703 }
1704
1705 template<> inline CSSPrimitiveValue::operator LineBreak() const
1706 {
1707     ASSERT(isValueID());
1708
1709     switch (m_value.valueID) {
1710     case CSSValueAuto:
1711         return LineBreakAuto;
1712     case CSSValueLoose:
1713         return LineBreakLoose;
1714     case CSSValueNormal:
1715         return LineBreakNormal;
1716     case CSSValueStrict:
1717         return LineBreakStrict;
1718     case CSSValueAfterWhiteSpace:
1719         return LineBreakAfterWhiteSpace;
1720     default:
1721         break;
1722     }
1723
1724     ASSERT_NOT_REACHED();
1725     return LineBreakAuto;
1726 }
1727
1728 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EListStylePosition e)
1729     : CSSValue(PrimitiveClass)
1730 {
1731     m_primitiveUnitType = CSS_VALUE_ID;
1732     switch (e) {
1733     case OUTSIDE:
1734         m_value.valueID = CSSValueOutside;
1735         break;
1736     case INSIDE:
1737         m_value.valueID = CSSValueInside;
1738         break;
1739     }
1740 }
1741
1742 template<> inline CSSPrimitiveValue::operator EListStylePosition() const
1743 {
1744     ASSERT(isValueID());
1745
1746     switch (m_value.valueID) {
1747     case CSSValueOutside:
1748         return OUTSIDE;
1749     case CSSValueInside:
1750         return INSIDE;
1751     default:
1752         break;
1753     }
1754
1755     ASSERT_NOT_REACHED();
1756     return OUTSIDE;
1757 }
1758
1759 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EListStyleType e)
1760     : CSSValue(PrimitiveClass)
1761 {
1762     m_primitiveUnitType = CSS_VALUE_ID;
1763     switch (e) {
1764     case Afar:
1765         m_value.valueID = CSSValueAfar;
1766         break;
1767     case Amharic:
1768         m_value.valueID = CSSValueAmharic;
1769         break;
1770     case AmharicAbegede:
1771         m_value.valueID = CSSValueAmharicAbegede;
1772         break;
1773     case ArabicIndic:
1774         m_value.valueID = CSSValueArabicIndic;
1775         break;
1776     case Armenian:
1777         m_value.valueID = CSSValueArmenian;
1778         break;
1779     case Asterisks:
1780         m_value.valueID = CSSValueAsterisks;
1781         break;
1782     case BinaryListStyle:
1783         m_value.valueID = CSSValueBinary;
1784         break;
1785     case Bengali:
1786         m_value.valueID = CSSValueBengali;
1787         break;
1788     case Cambodian:
1789         m_value.valueID = CSSValueCambodian;
1790         break;
1791     case Circle:
1792         m_value.valueID = CSSValueCircle;
1793         break;
1794     case CjkEarthlyBranch:
1795         m_value.valueID = CSSValueCjkEarthlyBranch;
1796         break;
1797     case CjkHeavenlyStem:
1798         m_value.valueID = CSSValueCjkHeavenlyStem;
1799         break;
1800     case CJKIdeographic:
1801         m_value.valueID = CSSValueCjkIdeographic;
1802         break;
1803     case DecimalLeadingZero:
1804         m_value.valueID = CSSValueDecimalLeadingZero;
1805         break;
1806     case DecimalListStyle:
1807         m_value.valueID = CSSValueDecimal;
1808         break;
1809     case Devanagari:
1810         m_value.valueID = CSSValueDevanagari;
1811         break;
1812     case Disc:
1813         m_value.valueID = CSSValueDisc;
1814         break;
1815     case Ethiopic:
1816         m_value.valueID = CSSValueEthiopic;
1817         break;
1818     case EthiopicAbegede:
1819         m_value.valueID = CSSValueEthiopicAbegede;
1820         break;
1821     case EthiopicAbegedeAmEt:
1822         m_value.valueID = CSSValueEthiopicAbegedeAmEt;
1823         break;
1824     case EthiopicAbegedeGez:
1825         m_value.valueID = CSSValueEthiopicAbegedeGez;
1826         break;
1827     case EthiopicAbegedeTiEr:
1828         m_value.valueID = CSSValueEthiopicAbegedeTiEr;
1829         break;
1830     case EthiopicAbegedeTiEt:
1831         m_value.valueID = CSSValueEthiopicAbegedeTiEt;
1832         break;
1833     case EthiopicHalehameAaEr:
1834         m_value.valueID = CSSValueEthiopicHalehameAaEr;
1835         break;
1836     case EthiopicHalehameAaEt:
1837         m_value.valueID = CSSValueEthiopicHalehameAaEt;
1838         break;
1839     case EthiopicHalehameAmEt:
1840         m_value.valueID = CSSValueEthiopicHalehameAmEt;
1841         break;
1842     case EthiopicHalehameGez:
1843         m_value.valueID = CSSValueEthiopicHalehameGez;
1844         break;
1845     case EthiopicHalehameOmEt:
1846         m_value.valueID = CSSValueEthiopicHalehameOmEt;
1847         break;
1848     case EthiopicHalehameSidEt:
1849         m_value.valueID = CSSValueEthiopicHalehameSidEt;
1850         break;
1851     case EthiopicHalehameSoEt:
1852         m_value.valueID = CSSValueEthiopicHalehameSoEt;
1853         break;
1854     case EthiopicHalehameTiEr:
1855         m_value.valueID = CSSValueEthiopicHalehameTiEr;
1856         break;
1857     case EthiopicHalehameTiEt:
1858         m_value.valueID = CSSValueEthiopicHalehameTiEt;
1859         break;
1860     case EthiopicHalehameTig:
1861         m_value.valueID = CSSValueEthiopicHalehameTig;
1862         break;
1863     case Footnotes:
1864         m_value.valueID = CSSValueFootnotes;
1865         break;
1866     case Georgian:
1867         m_value.valueID = CSSValueGeorgian;
1868         break;
1869     case Gujarati:
1870         m_value.valueID = CSSValueGujarati;
1871         break;
1872     case Gurmukhi:
1873         m_value.valueID = CSSValueGurmukhi;
1874         break;
1875     case Hangul:
1876         m_value.valueID = CSSValueHangul;
1877         break;
1878     case HangulConsonant:
1879         m_value.valueID = CSSValueHangulConsonant;
1880         break;
1881     case Hebrew:
1882         m_value.valueID = CSSValueHebrew;
1883         break;
1884     case Hiragana:
1885         m_value.valueID = CSSValueHiragana;
1886         break;
1887     case HiraganaIroha:
1888         m_value.valueID = CSSValueHiraganaIroha;
1889         break;
1890     case Kannada:
1891         m_value.valueID = CSSValueKannada;
1892         break;
1893     case Katakana:
1894         m_value.valueID = CSSValueKatakana;
1895         break;
1896     case KatakanaIroha:
1897         m_value.valueID = CSSValueKatakanaIroha;
1898         break;
1899     case Khmer:
1900         m_value.valueID = CSSValueKhmer;
1901         break;
1902     case Lao:
1903         m_value.valueID = CSSValueLao;
1904         break;
1905     case LowerAlpha:
1906         m_value.valueID = CSSValueLowerAlpha;
1907         break;
1908     case LowerArmenian:
1909         m_value.valueID = CSSValueLowerArmenian;
1910         break;
1911     case LowerGreek:
1912         m_value.valueID = CSSValueLowerGreek;
1913         break;
1914     case LowerHexadecimal:
1915         m_value.valueID = CSSValueLowerHexadecimal;
1916         break;
1917     case LowerLatin:
1918         m_value.valueID = CSSValueLowerLatin;
1919         break;
1920     case LowerNorwegian:
1921         m_value.valueID = CSSValueLowerNorwegian;
1922         break;
1923     case LowerRoman:
1924         m_value.valueID = CSSValueLowerRoman;
1925         break;
1926     case Malayalam:
1927         m_value.valueID = CSSValueMalayalam;
1928         break;
1929     case Mongolian:
1930         m_value.valueID = CSSValueMongolian;
1931         break;
1932     case Myanmar:
1933         m_value.valueID = CSSValueMyanmar;
1934         break;
1935     case NoneListStyle:
1936         m_value.valueID = CSSValueNone;
1937         break;
1938     case Octal:
1939         m_value.valueID = CSSValueOctal;
1940         break;
1941     case Oriya:
1942         m_value.valueID = CSSValueOriya;
1943         break;
1944     case Oromo:
1945         m_value.valueID = CSSValueOromo;
1946         break;
1947     case Persian:
1948         m_value.valueID = CSSValuePersian;
1949         break;
1950     case Sidama:
1951         m_value.valueID = CSSValueSidama;
1952         break;
1953     case Somali:
1954         m_value.valueID = CSSValueSomali;
1955         break;
1956     case Square:
1957         m_value.valueID = CSSValueSquare;
1958         break;
1959     case Telugu:
1960         m_value.valueID = CSSValueTelugu;
1961         break;
1962     case Thai:
1963         m_value.valueID = CSSValueThai;
1964         break;
1965     case Tibetan:
1966         m_value.valueID = CSSValueTibetan;
1967         break;
1968     case Tigre:
1969         m_value.valueID = CSSValueTigre;
1970         break;
1971     case TigrinyaEr:
1972         m_value.valueID = CSSValueTigrinyaEr;
1973         break;
1974     case TigrinyaErAbegede:
1975         m_value.valueID = CSSValueTigrinyaErAbegede;
1976         break;
1977     case TigrinyaEt:
1978         m_value.valueID = CSSValueTigrinyaEt;
1979         break;
1980     case TigrinyaEtAbegede:
1981         m_value.valueID = CSSValueTigrinyaEtAbegede;
1982         break;
1983     case UpperAlpha:
1984         m_value.valueID = CSSValueUpperAlpha;
1985         break;
1986     case UpperArmenian:
1987         m_value.valueID = CSSValueUpperArmenian;
1988         break;
1989     case UpperGreek:
1990         m_value.valueID = CSSValueUpperGreek;
1991         break;
1992     case UpperHexadecimal:
1993         m_value.valueID = CSSValueUpperHexadecimal;
1994         break;
1995     case UpperLatin:
1996         m_value.valueID = CSSValueUpperLatin;
1997         break;
1998     case UpperNorwegian:
1999         m_value.valueID = CSSValueUpperNorwegian;
2000         break;
2001     case UpperRoman:
2002         m_value.valueID = CSSValueUpperRoman;
2003         break;
2004     case Urdu:
2005         m_value.valueID = CSSValueUrdu;
2006         break;
2007     }
2008 }
2009
2010 template<> inline CSSPrimitiveValue::operator EListStyleType() const
2011 {
2012     ASSERT(isValueID());
2013
2014     switch (m_value.valueID) {
2015     case CSSValueNone:
2016         return NoneListStyle;
2017     default:
2018         return static_cast<EListStyleType>(m_value.valueID - CSSValueDisc);
2019     }
2020 }
2021
2022 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EMarginCollapse e)
2023     : CSSValue(PrimitiveClass)
2024 {
2025     m_primitiveUnitType = CSS_VALUE_ID;
2026     switch (e) {
2027     case MCOLLAPSE:
2028         m_value.valueID = CSSValueCollapse;
2029         break;
2030     case MSEPARATE:
2031         m_value.valueID = CSSValueSeparate;
2032         break;
2033     case MDISCARD:
2034         m_value.valueID = CSSValueDiscard;
2035         break;
2036     }
2037 }
2038
2039 template<> inline CSSPrimitiveValue::operator EMarginCollapse() const
2040 {
2041     ASSERT(isValueID());
2042
2043     switch (m_value.valueID) {
2044     case CSSValueCollapse:
2045         return MCOLLAPSE;
2046     case CSSValueSeparate:
2047         return MSEPARATE;
2048     case CSSValueDiscard:
2049         return MDISCARD;
2050     default:
2051         break;
2052     }
2053
2054     ASSERT_NOT_REACHED();
2055     return MCOLLAPSE;
2056 }
2057
2058 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EMarqueeBehavior e)
2059     : CSSValue(PrimitiveClass)
2060 {
2061     m_primitiveUnitType = CSS_VALUE_ID;
2062     switch (e) {
2063     case MNONE:
2064         m_value.valueID = CSSValueNone;
2065         break;
2066     case MSCROLL:
2067         m_value.valueID = CSSValueScroll;
2068         break;
2069     case MSLIDE:
2070         m_value.valueID = CSSValueSlide;
2071         break;
2072     case MALTERNATE:
2073         m_value.valueID = CSSValueAlternate;
2074         break;
2075     }
2076 }
2077
2078 template<> inline CSSPrimitiveValue::operator EMarqueeBehavior() const
2079 {
2080     ASSERT(isValueID());
2081
2082     switch (m_value.valueID) {
2083     case CSSValueNone:
2084         return MNONE;
2085     case CSSValueScroll:
2086         return MSCROLL;
2087     case CSSValueSlide:
2088         return MSLIDE;
2089     case CSSValueAlternate:
2090         return MALTERNATE;
2091     default:
2092         break;
2093     }
2094
2095     ASSERT_NOT_REACHED();
2096     return MNONE;
2097 }
2098
2099 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(RegionFragment e)
2100     : CSSValue(PrimitiveClass)
2101 {
2102     m_primitiveUnitType = CSS_VALUE_ID;
2103     switch (e) {
2104     case AutoRegionFragment:
2105         m_value.valueID = CSSValueAuto;
2106         break;
2107     case BreakRegionFragment:
2108         m_value.valueID = CSSValueBreak;
2109         break;
2110     }
2111 }
2112
2113 template<> inline CSSPrimitiveValue::operator RegionFragment() const
2114 {
2115     ASSERT(isValueID());
2116
2117     switch (m_value.valueID) {
2118     case CSSValueAuto:
2119         return AutoRegionFragment;
2120     case CSSValueBreak:
2121         return BreakRegionFragment;
2122     default:
2123         break;
2124     }
2125
2126     ASSERT_NOT_REACHED();
2127     return AutoRegionFragment;
2128 }
2129
2130 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EMarqueeDirection e)
2131     : CSSValue(PrimitiveClass)
2132 {
2133     m_primitiveUnitType = CSS_VALUE_ID;
2134     switch (e) {
2135     case MFORWARD:
2136         m_value.valueID = CSSValueForwards;
2137         break;
2138     case MBACKWARD:
2139         m_value.valueID = CSSValueBackwards;
2140         break;
2141     case MAUTO:
2142         m_value.valueID = CSSValueAuto;
2143         break;
2144     case MUP:
2145         m_value.valueID = CSSValueUp;
2146         break;
2147     case MDOWN:
2148         m_value.valueID = CSSValueDown;
2149         break;
2150     case MLEFT:
2151         m_value.valueID = CSSValueLeft;
2152         break;
2153     case MRIGHT:
2154         m_value.valueID = CSSValueRight;
2155         break;
2156     }
2157 }
2158
2159 template<> inline CSSPrimitiveValue::operator EMarqueeDirection() const
2160 {
2161     ASSERT(isValueID());
2162
2163     switch (m_value.valueID) {
2164     case CSSValueForwards:
2165         return MFORWARD;
2166     case CSSValueBackwards:
2167         return MBACKWARD;
2168     case CSSValueAuto:
2169         return MAUTO;
2170     case CSSValueAhead:
2171     case CSSValueUp: // We don't support vertical languages, so AHEAD just maps to UP.
2172         return MUP;
2173     case CSSValueReverse:
2174     case CSSValueDown: // REVERSE just maps to DOWN, since we don't do vertical text.
2175         return MDOWN;
2176     case CSSValueLeft:
2177         return MLEFT;
2178     case CSSValueRight:
2179         return MRIGHT;
2180     default:
2181         break;
2182     }
2183
2184     ASSERT_NOT_REACHED();
2185     return MAUTO;
2186 }
2187
2188 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ENBSPMode e)
2189     : CSSValue(PrimitiveClass)
2190 {
2191     m_primitiveUnitType = CSS_VALUE_ID;
2192     switch (e) {
2193     case NBNORMAL:
2194         m_value.valueID = CSSValueNormal;
2195         break;
2196     case SPACE:
2197         m_value.valueID = CSSValueSpace;
2198         break;
2199     }
2200 }
2201
2202 template<> inline CSSPrimitiveValue::operator ENBSPMode() const
2203 {
2204     ASSERT(isValueID());
2205
2206     switch (m_value.valueID) {
2207     case CSSValueSpace:
2208         return SPACE;
2209     case CSSValueNormal:
2210         return NBNORMAL;
2211     default:
2212         break;
2213     }
2214
2215     ASSERT_NOT_REACHED();
2216     return NBNORMAL;
2217 }
2218
2219 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EOverflow e)
2220     : CSSValue(PrimitiveClass)
2221 {
2222     m_primitiveUnitType = CSS_VALUE_ID;
2223     switch (e) {
2224     case OVISIBLE:
2225         m_value.valueID = CSSValueVisible;
2226         break;
2227     case OHIDDEN:
2228         m_value.valueID = CSSValueHidden;
2229         break;
2230     case OSCROLL:
2231         m_value.valueID = CSSValueScroll;
2232         break;
2233     case OAUTO:
2234         m_value.valueID = CSSValueAuto;
2235         break;
2236     case OMARQUEE:
2237         m_value.valueID = CSSValueWebkitMarquee;
2238         break;
2239     case OOVERLAY:
2240         m_value.valueID = CSSValueOverlay;
2241         break;
2242     case OPAGEDX:
2243         m_value.valueID = CSSValueWebkitPagedX;
2244         break;
2245     case OPAGEDY:
2246         m_value.valueID = CSSValueWebkitPagedY;
2247         break;
2248     }
2249 }
2250
2251 template<> inline CSSPrimitiveValue::operator EOverflow() const
2252 {
2253     ASSERT(isValueID());
2254
2255     switch (m_value.valueID) {
2256     case CSSValueVisible:
2257         return OVISIBLE;
2258     case CSSValueHidden:
2259         return OHIDDEN;
2260     case CSSValueScroll:
2261         return OSCROLL;
2262     case CSSValueAuto:
2263         return OAUTO;
2264     case CSSValueWebkitMarquee:
2265         return OMARQUEE;
2266     case CSSValueOverlay:
2267         return OOVERLAY;
2268     case CSSValueWebkitPagedX:
2269         return OPAGEDX;
2270     case CSSValueWebkitPagedY:
2271         return OPAGEDY;
2272     default:
2273         break;
2274     }
2275
2276     ASSERT_NOT_REACHED();
2277     return OVISIBLE;
2278 }
2279
2280 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EPageBreak e)
2281     : CSSValue(PrimitiveClass)
2282 {
2283     m_primitiveUnitType = CSS_VALUE_ID;
2284     switch (e) {
2285     case PBAUTO:
2286         m_value.valueID = CSSValueAuto;
2287         break;
2288     case PBALWAYS:
2289         m_value.valueID = CSSValueAlways;
2290         break;
2291     case PBAVOID:
2292         m_value.valueID = CSSValueAvoid;
2293         break;
2294     }
2295 }
2296
2297 template<> inline CSSPrimitiveValue::operator EPageBreak() const
2298 {
2299     ASSERT(isValueID());
2300
2301     switch (m_value.valueID) {
2302     case CSSValueAuto:
2303         return PBAUTO;
2304     case CSSValueLeft:
2305     case CSSValueRight:
2306     case CSSValueAlways:
2307         return PBALWAYS; // CSS2.1: "Conforming user agents may map left/right to always."
2308     case CSSValueAvoid:
2309         return PBAVOID;
2310     default:
2311         break;
2312     }
2313
2314     ASSERT_NOT_REACHED();
2315     return PBAUTO;
2316 }
2317
2318 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EPosition e)
2319     : CSSValue(PrimitiveClass)
2320 {
2321     m_primitiveUnitType = CSS_VALUE_ID;
2322     switch (e) {
2323     case StaticPosition:
2324         m_value.valueID = CSSValueStatic;
2325         break;
2326     case RelativePosition:
2327         m_value.valueID = CSSValueRelative;
2328         break;
2329     case AbsolutePosition:
2330         m_value.valueID = CSSValueAbsolute;
2331         break;
2332     case FixedPosition:
2333         m_value.valueID = CSSValueFixed;
2334         break;
2335     case StickyPosition:
2336         m_value.valueID = CSSValueWebkitSticky;
2337         break;
2338     }
2339 }
2340
2341 template<> inline CSSPrimitiveValue::operator EPosition() const
2342 {
2343     ASSERT(isValueID());
2344
2345     switch (m_value.valueID) {
2346     case CSSValueStatic:
2347         return StaticPosition;
2348     case CSSValueRelative:
2349         return RelativePosition;
2350     case CSSValueAbsolute:
2351         return AbsolutePosition;
2352     case CSSValueFixed:
2353         return FixedPosition;
2354     case CSSValueWebkitSticky:
2355         return StickyPosition;
2356     default:
2357         break;
2358     }
2359
2360     ASSERT_NOT_REACHED();
2361     return StaticPosition;
2362 }
2363
2364 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EResize e)
2365     : CSSValue(PrimitiveClass)
2366 {
2367     m_primitiveUnitType = CSS_VALUE_ID;
2368     switch (e) {
2369     case RESIZE_BOTH:
2370         m_value.valueID = CSSValueBoth;
2371         break;
2372     case RESIZE_HORIZONTAL:
2373         m_value.valueID = CSSValueHorizontal;
2374         break;
2375     case RESIZE_VERTICAL:
2376         m_value.valueID = CSSValueVertical;
2377         break;
2378     case RESIZE_NONE:
2379         m_value.valueID = CSSValueNone;
2380         break;
2381     }
2382 }
2383
2384 template<> inline CSSPrimitiveValue::operator EResize() const
2385 {
2386     ASSERT(isValueID());
2387
2388     switch (m_value.valueID) {
2389     case CSSValueBoth:
2390         return RESIZE_BOTH;
2391     case CSSValueHorizontal:
2392         return RESIZE_HORIZONTAL;
2393     case CSSValueVertical:
2394         return RESIZE_VERTICAL;
2395     case CSSValueAuto:
2396         ASSERT_NOT_REACHED(); // Depends on settings, thus should be handled by the caller.
2397         return RESIZE_NONE;
2398     case CSSValueNone:
2399         return RESIZE_NONE;
2400     default:
2401         break;
2402     }
2403
2404     ASSERT_NOT_REACHED();
2405     return RESIZE_NONE;
2406 }
2407
2408 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETableLayout e)
2409     : CSSValue(PrimitiveClass)
2410 {
2411     m_primitiveUnitType = CSS_VALUE_ID;
2412     switch (e) {
2413     case TAUTO:
2414         m_value.valueID = CSSValueAuto;
2415         break;
2416     case TFIXED:
2417         m_value.valueID = CSSValueFixed;
2418         break;
2419     }
2420 }
2421
2422 template<> inline CSSPrimitiveValue::operator ETableLayout() const
2423 {
2424     ASSERT(isValueID());
2425
2426     switch (m_value.valueID) {
2427     case CSSValueFixed:
2428         return TFIXED;
2429     case CSSValueAuto:
2430         return TAUTO;
2431     default:
2432         break;
2433     }
2434
2435     ASSERT_NOT_REACHED();
2436     return TAUTO;
2437 }
2438
2439 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETextAlign e)
2440     : CSSValue(PrimitiveClass)
2441 {
2442     m_primitiveUnitType = CSS_VALUE_ID;
2443     switch (e) {
2444     case TASTART:
2445         m_value.valueID = CSSValueStart;
2446         break;
2447     case TAEND:
2448         m_value.valueID = CSSValueEnd;
2449         break;
2450     case LEFT:
2451         m_value.valueID = CSSValueLeft;
2452         break;
2453     case RIGHT:
2454         m_value.valueID = CSSValueRight;
2455         break;
2456     case CENTER:
2457         m_value.valueID = CSSValueCenter;
2458         break;
2459     case JUSTIFY:
2460         m_value.valueID = CSSValueJustify;
2461         break;
2462     case WEBKIT_LEFT:
2463         m_value.valueID = CSSValueWebkitLeft;
2464         break;
2465     case WEBKIT_RIGHT:
2466         m_value.valueID = CSSValueWebkitRight;
2467         break;
2468     case WEBKIT_CENTER:
2469         m_value.valueID = CSSValueWebkitCenter;
2470         break;
2471     }
2472 }
2473
2474 template<> inline CSSPrimitiveValue::operator ETextAlign() const
2475 {
2476     ASSERT(isValueID());
2477
2478     switch (m_value.valueID) {
2479     case CSSValueWebkitAuto: // Legacy -webkit-auto. Eqiuvalent to start.
2480     case CSSValueStart:
2481         return TASTART;
2482     case CSSValueEnd:
2483         return TAEND;
2484     default:
2485         return static_cast<ETextAlign>(m_value.valueID - CSSValueLeft);
2486     }
2487 }
2488
2489 #if ENABLE(CSS3_TEXT)
2490 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextAlignLast e)
2491     : CSSValue(PrimitiveClass)
2492 {
2493     m_primitiveUnitType = CSS_VALUE_ID;
2494     switch (e) {
2495     case TextAlignLastStart:
2496         m_value.valueID = CSSValueStart;
2497         break;
2498     case TextAlignLastEnd:
2499         m_value.valueID = CSSValueEnd;
2500         break;
2501     case TextAlignLastLeft:
2502         m_value.valueID = CSSValueLeft;
2503         break;
2504     case TextAlignLastRight:
2505         m_value.valueID = CSSValueRight;
2506         break;
2507     case TextAlignLastCenter:
2508         m_value.valueID = CSSValueCenter;
2509         break;
2510     case TextAlignLastJustify:
2511         m_value.valueID = CSSValueJustify;
2512         break;
2513     case TextAlignLastAuto:
2514         m_value.valueID = CSSValueAuto;
2515         break;
2516     }
2517 }
2518
2519 template<> inline CSSPrimitiveValue::operator TextAlignLast() const
2520 {
2521     ASSERT(isValueID());
2522
2523     switch (m_value.valueID) {
2524     case CSSValueAuto:
2525         return TextAlignLastAuto;
2526     case CSSValueStart:
2527         return TextAlignLastStart;
2528     case CSSValueEnd:
2529         return TextAlignLastEnd;
2530     case CSSValueLeft:
2531         return TextAlignLastLeft;
2532     case CSSValueRight:
2533         return TextAlignLastRight;
2534     case CSSValueCenter:
2535         return TextAlignLastCenter;
2536     case CSSValueJustify:
2537         return TextAlignLastJustify;
2538     default:
2539         break;
2540     }
2541
2542     ASSERT_NOT_REACHED();
2543     return TextAlignLastAuto;
2544 }
2545
2546 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextJustify e)
2547     : CSSValue(PrimitiveClass)
2548 {
2549     m_primitiveUnitType = CSS_VALUE_ID;
2550     switch (e) {
2551     case TextJustifyAuto:
2552         m_value.valueID = CSSValueAuto;
2553         break;
2554     case TextJustifyNone:
2555         m_value.valueID = CSSValueNone;
2556         break;
2557     case TextJustifyInterWord:
2558         m_value.valueID = CSSValueInterWord;
2559         break;
2560     case TextJustifyDistribute:
2561         m_value.valueID = CSSValueDistribute;
2562         break;
2563     }
2564 }
2565
2566 template<> inline CSSPrimitiveValue::operator TextJustify() const
2567 {
2568     ASSERT(isValueID());
2569
2570     switch (m_value.valueID) {
2571     case CSSValueAuto:
2572         return TextJustifyAuto;
2573     case CSSValueNone:
2574         return TextJustifyNone;
2575     case CSSValueInterWord:
2576         return TextJustifyInterWord;
2577     case CSSValueDistribute:
2578         return TextJustifyDistribute;
2579     default:
2580         break;
2581     }
2582
2583     ASSERT_NOT_REACHED();
2584     return TextJustifyAuto;
2585 }
2586 #endif // CSS3_TEXT
2587
2588 template<> inline CSSPrimitiveValue::operator TextDecoration() const
2589 {
2590     ASSERT(isValueID());
2591
2592     switch (m_value.valueID) {
2593     case CSSValueNone:
2594         return TextDecorationNone;
2595     case CSSValueUnderline:
2596         return TextDecorationUnderline;
2597     case CSSValueOverline:
2598         return TextDecorationOverline;
2599     case CSSValueLineThrough:
2600         return TextDecorationLineThrough;
2601     case CSSValueBlink:
2602         return TextDecorationBlink;
2603 #if ENABLE(LETTERPRESS)
2604     case CSSValueWebkitLetterpress:
2605         return TextDecorationLetterpress;
2606 #endif
2607     default:
2608         break;
2609     }
2610
2611     ASSERT_NOT_REACHED();
2612     return TextDecorationNone;
2613 }
2614
2615 template<> inline CSSPrimitiveValue::operator TextDecorationStyle() const
2616 {
2617     ASSERT(isValueID());
2618
2619     switch (m_value.valueID) {
2620     case CSSValueSolid:
2621         return TextDecorationStyleSolid;
2622     case CSSValueDouble:
2623         return TextDecorationStyleDouble;
2624     case CSSValueDotted:
2625         return TextDecorationStyleDotted;
2626     case CSSValueDashed:
2627         return TextDecorationStyleDashed;
2628     case CSSValueWavy:
2629         return TextDecorationStyleWavy;
2630     default:
2631         break;
2632     }
2633
2634     ASSERT_NOT_REACHED();
2635     return TextDecorationStyleSolid;
2636 }
2637
2638 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextUnderlinePosition e)
2639     : CSSValue(PrimitiveClass)
2640 {
2641     m_primitiveUnitType = CSS_VALUE_ID;
2642     switch (e) {
2643     case TextUnderlinePositionAuto:
2644         m_value.valueID = CSSValueAuto;
2645         break;
2646     case TextUnderlinePositionAlphabetic:
2647         m_value.valueID = CSSValueAlphabetic;
2648         break;
2649     case TextUnderlinePositionUnder:
2650         m_value.valueID = CSSValueUnder;
2651         break;
2652     }
2653
2654     // FIXME: Implement support for 'under left' and 'under right' values.
2655 }
2656
2657 template<> inline CSSPrimitiveValue::operator TextUnderlinePosition() const
2658 {
2659     ASSERT(isValueID());
2660
2661     switch (m_value.valueID) {
2662     case CSSValueAuto:
2663         return TextUnderlinePositionAuto;
2664     case CSSValueAlphabetic:
2665         return TextUnderlinePositionAlphabetic;
2666     case CSSValueUnder:
2667         return TextUnderlinePositionUnder;
2668     default:
2669         break;
2670     }
2671
2672     // FIXME: Implement support for 'under left' and 'under right' values.
2673
2674     ASSERT_NOT_REACHED();
2675     return TextUnderlinePositionAuto;
2676 }
2677
2678 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETextSecurity e)
2679     : CSSValue(PrimitiveClass)
2680 {
2681     m_primitiveUnitType = CSS_VALUE_ID;
2682     switch (e) {
2683     case TSNONE:
2684         m_value.valueID = CSSValueNone;
2685         break;
2686     case TSDISC:
2687         m_value.valueID = CSSValueDisc;
2688         break;
2689     case TSCIRCLE:
2690         m_value.valueID = CSSValueCircle;
2691         break;
2692     case TSSQUARE:
2693         m_value.valueID = CSSValueSquare;
2694         break;
2695     }
2696 }
2697
2698 template<> inline CSSPrimitiveValue::operator ETextSecurity() const
2699 {
2700     ASSERT(isValueID());
2701
2702     switch (m_value.valueID) {
2703     case CSSValueNone:
2704         return TSNONE;
2705     case CSSValueDisc:
2706         return TSDISC;
2707     case CSSValueCircle:
2708         return TSCIRCLE;
2709     case CSSValueSquare:
2710         return TSSQUARE;
2711     default:
2712         break;
2713     }
2714
2715     ASSERT_NOT_REACHED();
2716     return TSNONE;
2717 }
2718
2719 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETextTransform e)
2720     : CSSValue(PrimitiveClass)
2721 {
2722     m_primitiveUnitType = CSS_VALUE_ID;
2723     switch (e) {
2724     case CAPITALIZE:
2725         m_value.valueID = CSSValueCapitalize;
2726         break;
2727     case UPPERCASE:
2728         m_value.valueID = CSSValueUppercase;
2729         break;
2730     case LOWERCASE:
2731         m_value.valueID = CSSValueLowercase;
2732         break;
2733     case TTNONE:
2734         m_value.valueID = CSSValueNone;
2735         break;
2736     }
2737 }
2738
2739 template<> inline CSSPrimitiveValue::operator ETextTransform() const
2740 {
2741     ASSERT(isValueID());
2742
2743     switch (m_value.valueID) {
2744     case CSSValueCapitalize:
2745         return CAPITALIZE;
2746     case CSSValueUppercase:
2747         return UPPERCASE;
2748     case CSSValueLowercase:
2749         return LOWERCASE;
2750     case CSSValueNone:
2751         return TTNONE;
2752     default:
2753         break;
2754     }
2755
2756     ASSERT_NOT_REACHED();
2757     return TTNONE;
2758 }
2759
2760 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUnicodeBidi e)
2761     : CSSValue(PrimitiveClass)
2762 {
2763     m_primitiveUnitType = CSS_VALUE_ID;
2764     switch (e) {
2765     case UBNormal:
2766         m_value.valueID = CSSValueNormal;
2767         break;
2768     case Embed:
2769         m_value.valueID = CSSValueEmbed;
2770         break;
2771     case Override:
2772         m_value.valueID = CSSValueBidiOverride;
2773         break;
2774     case Isolate:
2775         m_value.valueID = CSSValueWebkitIsolate;
2776         break;
2777     case IsolateOverride:
2778         m_value.valueID = CSSValueWebkitIsolateOverride;
2779         break;
2780     case Plaintext:
2781         m_value.valueID = CSSValueWebkitPlaintext;
2782         break;
2783     }
2784 }
2785
2786 template<> inline CSSPrimitiveValue::operator EUnicodeBidi() const
2787 {
2788     ASSERT(isValueID());
2789
2790     switch (m_value.valueID) {
2791     case CSSValueNormal:
2792         return UBNormal;
2793     case CSSValueEmbed:
2794         return Embed;
2795     case CSSValueBidiOverride:
2796         return Override;
2797     case CSSValueWebkitIsolate:
2798         return Isolate;
2799     case CSSValueWebkitIsolateOverride:
2800         return IsolateOverride;
2801     case CSSValueWebkitPlaintext:
2802         return Plaintext;
2803     default:
2804         break;
2805     }
2806
2807     ASSERT_NOT_REACHED();
2808     return UBNormal;
2809 }
2810
2811 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUserDrag e)
2812     : CSSValue(PrimitiveClass)
2813 {
2814     m_primitiveUnitType = CSS_VALUE_ID;
2815     switch (e) {
2816     case DRAG_AUTO:
2817         m_value.valueID = CSSValueAuto;
2818         break;
2819     case DRAG_NONE:
2820         m_value.valueID = CSSValueNone;
2821         break;
2822     case DRAG_ELEMENT:
2823         m_value.valueID = CSSValueElement;
2824         break;
2825     default:
2826         break;
2827     }
2828 }
2829
2830 template<> inline CSSPrimitiveValue::operator EUserDrag() const
2831 {
2832     ASSERT(isValueID());
2833
2834     switch (m_value.valueID) {
2835     case CSSValueAuto:
2836         return DRAG_AUTO;
2837     case CSSValueNone:
2838         return DRAG_NONE;
2839     case CSSValueElement:
2840         return DRAG_ELEMENT;
2841     default:
2842         break;
2843     }
2844
2845     ASSERT_NOT_REACHED();
2846     return DRAG_AUTO;
2847 }
2848
2849 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUserModify e)
2850     : CSSValue(PrimitiveClass)
2851 {
2852     m_primitiveUnitType = CSS_VALUE_ID;
2853     switch (e) {
2854     case READ_ONLY:
2855         m_value.valueID = CSSValueReadOnly;
2856         break;
2857     case READ_WRITE:
2858         m_value.valueID = CSSValueReadWrite;
2859         break;
2860     case READ_WRITE_PLAINTEXT_ONLY:
2861         m_value.valueID = CSSValueReadWritePlaintextOnly;
2862         break;
2863     }
2864 }
2865
2866 template<> inline CSSPrimitiveValue::operator EUserModify() const
2867 {
2868     ASSERT(isValueID());
2869
2870     switch (m_value.valueID) {
2871     case CSSValueReadOnly:
2872         return READ_ONLY;
2873     case CSSValueReadWrite:
2874         return READ_WRITE;
2875     case CSSValueReadWritePlaintextOnly:
2876         return READ_WRITE_PLAINTEXT_ONLY;
2877     default:
2878         break;
2879     }
2880
2881     ASSERT_NOT_REACHED();
2882     return READ_ONLY;
2883 }
2884
2885 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUserSelect e)
2886     : CSSValue(PrimitiveClass)
2887 {
2888     m_primitiveUnitType = CSS_VALUE_ID;
2889     switch (e) {
2890     case SELECT_NONE:
2891         m_value.valueID = CSSValueNone;
2892         break;
2893     case SELECT_TEXT:
2894         m_value.valueID = CSSValueText;
2895         break;
2896     case SELECT_ALL:
2897         m_value.valueID = CSSValueAll;
2898         break;
2899     }
2900 }
2901
2902 template<> inline CSSPrimitiveValue::operator EUserSelect() const
2903 {
2904     ASSERT(isValueID());
2905
2906     switch (m_value.valueID) {
2907     case CSSValueAuto:
2908         return SELECT_TEXT;
2909     case CSSValueNone:
2910         return SELECT_NONE;
2911     case CSSValueText:
2912         return SELECT_TEXT;
2913     case CSSValueAll:
2914         return SELECT_ALL;
2915     default:
2916         break;
2917     }
2918
2919     ASSERT_NOT_REACHED();
2920     return SELECT_TEXT;
2921 }
2922
2923 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EVerticalAlign a)
2924     : CSSValue(PrimitiveClass)
2925 {
2926     m_primitiveUnitType = CSS_VALUE_ID;
2927     switch (a) {
2928     case TOP:
2929         m_value.valueID = CSSValueTop;
2930         break;
2931     case BOTTOM:
2932         m_value.valueID = CSSValueBottom;
2933         break;
2934     case MIDDLE:
2935         m_value.valueID = CSSValueMiddle;
2936         break;
2937     case BASELINE:
2938         m_value.valueID = CSSValueBaseline;
2939         break;
2940     case TEXT_BOTTOM:
2941         m_value.valueID = CSSValueTextBottom;
2942         break;
2943     case TEXT_TOP:
2944         m_value.valueID = CSSValueTextTop;
2945         break;
2946     case SUB:
2947         m_value.valueID = CSSValueSub;
2948         break;
2949     case SUPER:
2950         m_value.valueID = CSSValueSuper;
2951         break;
2952     case BASELINE_MIDDLE:
2953         m_value.valueID = CSSValueWebkitBaselineMiddle;
2954         break;
2955     case LENGTH:
2956         m_value.valueID = CSSValueInvalid;
2957     }
2958 }
2959
2960 template<> inline CSSPrimitiveValue::operator EVerticalAlign() const
2961 {
2962     ASSERT(isValueID());
2963
2964     switch (m_value.valueID) {
2965     case CSSValueTop:
2966         return TOP;
2967     case CSSValueBottom:
2968         return BOTTOM;
2969     case CSSValueMiddle:
2970         return MIDDLE;
2971     case CSSValueBaseline:
2972         return BASELINE;
2973     case CSSValueTextBottom:
2974         return TEXT_BOTTOM;
2975     case CSSValueTextTop:
2976         return TEXT_TOP;
2977     case CSSValueSub:
2978         return SUB;
2979     case CSSValueSuper:
2980         return SUPER;
2981     case CSSValueWebkitBaselineMiddle:
2982         return BASELINE_MIDDLE;
2983     default:
2984         break;
2985     }
2986
2987     ASSERT_NOT_REACHED();
2988     return TOP;
2989 }
2990
2991 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EVisibility e)
2992     : CSSValue(PrimitiveClass)
2993 {
2994     m_primitiveUnitType = CSS_VALUE_ID;
2995     switch (e) {
2996     case VISIBLE:
2997         m_value.valueID = CSSValueVisible;
2998         break;
2999     case HIDDEN:
3000         m_value.valueID = CSSValueHidden;
3001         break;
3002     case COLLAPSE:
3003         m_value.valueID = CSSValueCollapse;
3004         break;
3005     }
3006 }
3007
3008 template<> inline CSSPrimitiveValue::operator EVisibility() const
3009 {
3010     ASSERT(isValueID());
3011
3012     switch (m_value.valueID) {
3013     case CSSValueHidden:
3014         return HIDDEN;
3015     case CSSValueVisible:
3016         return VISIBLE;
3017     case CSSValueCollapse:
3018         return COLLAPSE;
3019     default:
3020         break;
3021     }
3022
3023     ASSERT_NOT_REACHED();
3024     return VISIBLE;
3025 }
3026
3027 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EWhiteSpace e)
3028     : CSSValue(PrimitiveClass)
3029 {
3030     m_primitiveUnitType = CSS_VALUE_ID;
3031     switch (e) {
3032     case NORMAL:
3033         m_value.valueID = CSSValueNormal;
3034         break;
3035     case PRE:
3036         m_value.valueID = CSSValuePre;
3037         break;
3038     case PRE_WRAP:
3039         m_value.valueID = CSSValuePreWrap;
3040         break;
3041     case PRE_LINE:
3042         m_value.valueID = CSSValuePreLine;
3043         break;
3044     case NOWRAP:
3045         m_value.valueID = CSSValueNowrap;
3046         break;
3047     case KHTML_NOWRAP:
3048         m_value.valueID = CSSValueWebkitNowrap;
3049         break;
3050     }
3051 }
3052
3053 template<> inline CSSPrimitiveValue::operator EWhiteSpace() const
3054 {
3055     ASSERT(isValueID());
3056
3057     switch (m_value.valueID) {
3058     case CSSValueWebkitNowrap:
3059         return KHTML_NOWRAP;
3060     case CSSValueNowrap:
3061         return NOWRAP;
3062     case CSSValuePre:
3063         return PRE;
3064     case CSSValuePreWrap:
3065         return PRE_WRAP;
3066     case CSSValuePreLine:
3067         return PRE_LINE;
3068     case CSSValueNormal:
3069         return NORMAL;
3070     default:
3071         break;
3072     }
3073
3074     ASSERT_NOT_REACHED();
3075     return NORMAL;
3076 }
3077
3078 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EWordBreak e)
3079     : CSSValue(PrimitiveClass)
3080 {
3081     m_primitiveUnitType = CSS_VALUE_ID;
3082     switch (e) {
3083     case NormalWordBreak:
3084         m_value.valueID = CSSValueNormal;
3085         break;
3086     case BreakAllWordBreak:
3087         m_value.valueID = CSSValueBreakAll;
3088         break;
3089     case BreakWordBreak:
3090         m_value.valueID = CSSValueBreakWord;
3091         break;
3092     }
3093 }
3094
3095 template<> inline CSSPrimitiveValue::operator EWordBreak() const
3096 {
3097     ASSERT(isValueID());
3098
3099     switch (m_value.valueID) {
3100     case CSSValueBreakAll:
3101         return BreakAllWordBreak;
3102     case CSSValueBreakWord:
3103         return BreakWordBreak;
3104     case CSSValueNormal:
3105         return NormalWordBreak;
3106     default:
3107         break;
3108     }
3109
3110     ASSERT_NOT_REACHED();
3111     return NormalWordBreak;
3112 }
3113
3114 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EOverflowWrap e)
3115     : CSSValue(PrimitiveClass)
3116 {
3117     m_primitiveUnitType = CSS_VALUE_ID;
3118     switch (e) {
3119     case NormalOverflowWrap:
3120         m_value.valueID = CSSValueNormal;
3121         break;
3122     case BreakOverflowWrap:
3123         m_value.valueID = CSSValueBreakWord;
3124         break;
3125     }
3126 }
3127
3128 template<> inline CSSPrimitiveValue::operator EOverflowWrap() const
3129 {
3130     ASSERT(isValueID());
3131
3132     switch (m_value.valueID) {
3133     case CSSValueBreakWord:
3134         return BreakOverflowWrap;
3135     case CSSValueNormal:
3136         return NormalOverflowWrap;
3137     default:
3138         break;
3139     }
3140
3141     ASSERT_NOT_REACHED();
3142     return NormalOverflowWrap;
3143 }
3144
3145 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextDirection e)
3146     : CSSValue(PrimitiveClass)
3147 {
3148     m_primitiveUnitType = CSS_VALUE_ID;
3149     switch (e) {
3150     case LTR:
3151         m_value.valueID = CSSValueLtr;
3152         break;
3153     case RTL:
3154         m_value.valueID = CSSValueRtl;
3155         break;
3156     }
3157 }
3158
3159 template<> inline CSSPrimitiveValue::operator TextDirection() const
3160 {
3161     ASSERT(isValueID());
3162
3163     switch (m_value.valueID) {
3164     case CSSValueLtr:
3165         return LTR;
3166     case CSSValueRtl:
3167         return RTL;
3168     default:
3169         break;
3170     }
3171
3172     ASSERT_NOT_REACHED();
3173     return LTR;
3174 }
3175
3176 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(WritingMode e)
3177     : CSSValue(PrimitiveClass)
3178 {
3179     m_primitiveUnitType = CSS_VALUE_ID;
3180     switch (e) {
3181     case TopToBottomWritingMode:
3182         m_value.valueID = CSSValueHorizontalTb;
3183         break;
3184     case RightToLeftWritingMode:
3185         m_value.valueID = CSSValueVerticalRl;
3186         break;
3187     case LeftToRightWritingMode:
3188         m_value.valueID = CSSValueVerticalLr;
3189         break;
3190     case BottomToTopWritingMode:
3191         m_value.valueID = CSSValueHorizontalBt;
3192         break;
3193     }
3194 }
3195
3196 template<> inline CSSPrimitiveValue::operator WritingMode() const
3197 {
3198     ASSERT(isValueID());
3199
3200     switch (m_value.valueID) {
3201     case CSSValueHorizontalTb:
3202         return TopToBottomWritingMode;
3203     case CSSValueVerticalRl:
3204         return RightToLeftWritingMode;
3205     case CSSValueVerticalLr:
3206         return LeftToRightWritingMode;
3207     case CSSValueHorizontalBt:
3208         return BottomToTopWritingMode;
3209     default:
3210         break;
3211     }
3212
3213     ASSERT_NOT_REACHED();
3214     return TopToBottomWritingMode;
3215 }
3216
3217 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextCombine e)
3218     : CSSValue(PrimitiveClass)
3219 {
3220     m_primitiveUnitType = CSS_VALUE_ID;
3221     switch (e) {
3222     case TextCombineNone:
3223         m_value.valueID = CSSValueNone;
3224         break;
3225     case TextCombineHorizontal:
3226         m_value.valueID = CSSValueHorizontal;
3227         break;
3228     }
3229 }
3230
3231 template<> inline CSSPrimitiveValue::operator TextCombine() const
3232 {
3233     ASSERT(isValueID());
3234
3235     switch (m_value.valueID) {
3236     case CSSValueNone:
3237         return TextCombineNone;
3238     case CSSValueHorizontal:
3239         return TextCombineHorizontal;
3240     default:
3241         break;
3242     }
3243
3244     ASSERT_NOT_REACHED();
3245     return TextCombineNone;
3246 }
3247
3248 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(RubyPosition position)
3249     : CSSValue(PrimitiveClass)
3250 {
3251     m_primitiveUnitType = CSS_VALUE_ID;
3252     switch (position) {
3253     case RubyPositionBefore:
3254         m_value.valueID = CSSValueBefore;
3255         break;
3256     case RubyPositionAfter:
3257         m_value.valueID = CSSValueAfter;
3258         break;
3259     }
3260 }
3261
3262 template<> inline CSSPrimitiveValue::operator RubyPosition() const
3263 {
3264     ASSERT(isValueID());
3265
3266     switch (m_value.valueID) {
3267     case CSSValueBefore:
3268         return RubyPositionBefore;
3269     case CSSValueAfter:
3270         return RubyPositionAfter;
3271     default:
3272         break;
3273     }
3274
3275     ASSERT_NOT_REACHED();
3276     return RubyPositionBefore;
3277 }
3278
3279 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextOverflow overflow)
3280     : CSSValue(PrimitiveClass)
3281 {
3282     m_primitiveUnitType = CSS_VALUE_ID;
3283     switch (overflow) {
3284     case TextOverflowClip:
3285         m_value.valueID = CSSValueClip;
3286         break;
3287     case TextOverflowEllipsis:
3288         m_value.valueID = CSSValueEllipsis;
3289         break;
3290     }
3291 }
3292
3293 template<> inline CSSPrimitiveValue::operator TextOverflow() const
3294 {
3295     ASSERT(isValueID());
3296
3297     switch (m_value.valueID) {
3298     case CSSValueClip:
3299         return TextOverflowClip;
3300     case CSSValueEllipsis:
3301         return TextOverflowEllipsis;
3302     default:
3303         break;
3304     }
3305
3306     ASSERT_NOT_REACHED();
3307     return TextOverflowClip;
3308 }
3309
3310 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextEmphasisFill fill)
3311     : CSSValue(PrimitiveClass)
3312 {
3313     m_primitiveUnitType = CSS_VALUE_ID;
3314     switch (fill) {
3315     case TextEmphasisFillFilled:
3316         m_value.valueID = CSSValueFilled;
3317         break;
3318     case TextEmphasisFillOpen:
3319         m_value.valueID = CSSValueOpen;
3320         break;
3321     }
3322 }
3323
3324 template<> inline CSSPrimitiveValue::operator TextEmphasisFill() const
3325 {
3326     ASSERT(isValueID());
3327
3328     switch (m_value.valueID) {
3329     case CSSValueFilled:
3330         return TextEmphasisFillFilled;
3331     case CSSValueOpen:
3332         return TextEmphasisFillOpen;
3333     default:
3334         break;
3335     }
3336
3337     ASSERT_NOT_REACHED();
3338     return TextEmphasisFillFilled;
3339 }
3340
3341 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextEmphasisMark mark)
3342     : CSSValue(PrimitiveClass)
3343 {
3344     m_primitiveUnitType = CSS_VALUE_ID;
3345     switch (mark) {
3346     case TextEmphasisMarkDot:
3347         m_value.valueID = CSSValueDot;
3348         break;
3349     case TextEmphasisMarkCircle:
3350         m_value.valueID = CSSValueCircle;
3351         break;
3352     case TextEmphasisMarkDoubleCircle:
3353         m_value.valueID = CSSValueDoubleCircle;
3354         break;
3355     case TextEmphasisMarkTriangle:
3356         m_value.valueID = CSSValueTriangle;
3357         break;
3358     case TextEmphasisMarkSesame:
3359         m_value.valueID = CSSValueSesame;
3360         break;
3361     case TextEmphasisMarkNone:
3362     case TextEmphasisMarkAuto:
3363     case TextEmphasisMarkCustom:
3364         ASSERT_NOT_REACHED();
3365         m_value.valueID = CSSValueNone;
3366         break;
3367     }
3368 }
3369
3370 template<> inline CSSPrimitiveValue::operator TextEmphasisMark() const
3371 {
3372     ASSERT(isValueID());
3373
3374     switch (m_value.valueID) {
3375     case CSSValueNone:
3376         return TextEmphasisMarkNone;
3377     case CSSValueDot:
3378         return TextEmphasisMarkDot;
3379     case CSSValueCircle:
3380         return TextEmphasisMarkCircle;
3381     case CSSValueDoubleCircle:
3382         return TextEmphasisMarkDoubleCircle;
3383     case CSSValueTriangle:
3384         return TextEmphasisMarkTriangle;
3385     case CSSValueSesame:
3386         return TextEmphasisMarkSesame;
3387     default:
3388         break;
3389     }
3390
3391     ASSERT_NOT_REACHED();
3392     return TextEmphasisMarkNone;
3393 }
3394
3395 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextOrientation e)
3396     : CSSValue(PrimitiveClass)
3397 {
3398     m_primitiveUnitType = CSS_VALUE_ID;
3399     switch (e) {
3400     case TextOrientationSideways:
3401         m_value.valueID = CSSValueSideways;
3402         break;
3403     case TextOrientationSidewaysRight:
3404         m_value.valueID = CSSValueSidewaysRight;
3405         break;
3406     case TextOrientationVerticalRight:
3407         m_value.valueID = CSSValueVerticalRight;
3408         break;
3409     case TextOrientationUpright:
3410         m_value.valueID = CSSValueUpright;
3411         break;
3412     }
3413 }
3414
3415 template<> inline CSSPrimitiveValue::operator TextOrientation() const
3416 {
3417     ASSERT(isValueID());
3418
3419     switch (m_value.valueID) {
3420     case CSSValueSideways:
3421         return TextOrientationSideways;
3422     case CSSValueSidewaysRight:
3423         return TextOrientationSidewaysRight;
3424     case CSSValueVerticalRight:
3425         return TextOrientationVerticalRight;
3426     case CSSValueUpright:
3427         return TextOrientationUpright;
3428     default:
3429         break;
3430     }
3431
3432     ASSERT_NOT_REACHED();
3433     return TextOrientationVerticalRight;
3434 }
3435
3436 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EPointerEvents e)
3437     : CSSValue(PrimitiveClass)
3438 {
3439     m_primitiveUnitType = CSS_VALUE_ID;
3440     switch (e) {
3441     case PE_NONE:
3442         m_value.valueID = CSSValueNone;
3443         break;
3444     case PE_STROKE:
3445         m_value.valueID = CSSValueStroke;
3446         break;
3447     case PE_FILL:
3448         m_value.valueID = CSSValueFill;
3449         break;
3450     case PE_PAINTED:
3451         m_value.valueID = CSSValuePainted;
3452         break;
3453     case PE_VISIBLE:
3454         m_value.valueID = CSSValueVisible;
3455         break;
3456     case PE_VISIBLE_STROKE:
3457         m_value.valueID = CSSValueVisiblestroke;
3458         break;
3459     case PE_VISIBLE_FILL:
3460         m_value.valueID = CSSValueVisiblefill;
3461         break;
3462     case PE_VISIBLE_PAINTED:
3463         m_value.valueID = CSSValueVisiblepainted;
3464         break;
3465     case PE_AUTO:
3466         m_value.valueID = CSSValueAuto;
3467         break;
3468     case PE_ALL:
3469         m_value.valueID = CSSValueAll;
3470         break;
3471     }
3472 }
3473
3474 template<> inline CSSPrimitiveValue::operator EPointerEvents() const
3475 {
3476     ASSERT(isValueID());
3477
3478     switch (m_value.valueID) {
3479     case CSSValueAll:
3480         return PE_ALL;
3481     case CSSValueAuto:
3482         return PE_AUTO;
3483     case CSSValueNone:
3484         return PE_NONE;
3485     case CSSValueVisiblepainted:
3486         return PE_VISIBLE_PAINTED;
3487     case CSSValueVisiblefill:
3488         return PE_VISIBLE_FILL;
3489     case CSSValueVisiblestroke:
3490         return PE_VISIBLE_STROKE;
3491     case CSSValueVisible:
3492         return PE_VISIBLE;
3493     case CSSValuePainted:
3494         return PE_PAINTED;
3495     case CSSValueFill:
3496         return PE_FILL;
3497     case CSSValueStroke:
3498         return PE_STROKE;
3499     default:
3500         break;
3501     }
3502
3503     ASSERT_NOT_REACHED();
3504     return PE_ALL;
3505 }
3506
3507 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontDescription::Kerning kerning)
3508     : CSSValue(PrimitiveClass)
3509 {
3510     m_primitiveUnitType = CSS_VALUE_ID;
3511     switch (kerning) {
3512     case FontDescription::AutoKerning:
3513         m_value.valueID = CSSValueAuto;
3514         return;
3515     case FontDescription::NormalKerning:
3516         m_value.valueID = CSSValueNormal;
3517         return;
3518     case FontDescription::NoneKerning:
3519         m_value.valueID = CSSValueNone;
3520         return;
3521     }
3522
3523     ASSERT_NOT_REACHED();
3524     m_value.valueID = CSSValueAuto;
3525 }
3526
3527 template<> inline CSSPrimitiveValue::operator FontDescription::Kerning() const
3528 {
3529     ASSERT(isValueID());
3530
3531     switch (m_value.valueID) {
3532     case CSSValueAuto:
3533         return FontDescription::AutoKerning;
3534     case CSSValueNormal:
3535         return FontDescription::NormalKerning;
3536     case CSSValueNone:
3537         return FontDescription::NoneKerning;
3538     default:
3539         break;
3540     }
3541
3542     ASSERT_NOT_REACHED();
3543     return FontDescription::AutoKerning;
3544 }
3545
3546 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ObjectFit fit)
3547     : CSSValue(PrimitiveClass)
3548 {
3549     m_primitiveUnitType = CSS_VALUE_ID;
3550     switch (fit) {
3551     case ObjectFitFill:
3552         m_value.valueID = CSSValueFill;
3553         break;
3554     case ObjectFitContain:
3555         m_value.valueID = CSSValueContain;
3556         break;
3557     case ObjectFitCover:
3558         m_value.valueID = CSSValueCover;
3559         break;
3560     case ObjectFitNone:
3561         m_value.valueID = CSSValueNone;
3562         break;
3563     case ObjectFitScaleDown:
3564         m_value.valueID = CSSValueScaleDown;
3565         break;
3566     }
3567 }
3568
3569 template<> inline CSSPrimitiveValue::operator ObjectFit() const
3570 {
3571     ASSERT(isValueID());
3572
3573     switch (m_value.valueID) {
3574     case CSSValueFill:
3575         return ObjectFitFill;
3576     case CSSValueContain:
3577         return ObjectFitContain;
3578     case CSSValueCover:
3579         return ObjectFitCover;
3580     case CSSValueNone:
3581         return ObjectFitNone;
3582     case CSSValueScaleDown:
3583         return ObjectFitScaleDown;
3584     default:
3585         ASSERT_NOT_REACHED();
3586         return ObjectFitFill;
3587     }
3588 }
3589
3590 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontSmoothingMode smoothing)
3591     : CSSValue(PrimitiveClass)
3592 {
3593     m_primitiveUnitType = CSS_VALUE_ID;
3594     switch (smoothing) {
3595     case AutoSmoothing:
3596         m_value.valueID = CSSValueAuto;
3597         return;
3598     case NoSmoothing:
3599         m_value.valueID = CSSValueNone;
3600         return;
3601     case Antialiased:
3602         m_value.valueID = CSSValueAntialiased;
3603         return;
3604     case SubpixelAntialiased:
3605         m_value.valueID = CSSValueSubpixelAntialiased;
3606