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