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