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