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