Support break-after, break-before and break-inside.
[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(EFlexDirection e)
1442     : CSSValue(PrimitiveClass)
1443 {
1444     m_primitiveUnitType = CSS_VALUE_ID;
1445     switch (e) {
1446     case FlowRow:
1447         m_value.valueID = CSSValueRow;
1448         break;
1449     case FlowRowReverse:
1450         m_value.valueID = CSSValueRowReverse;
1451         break;
1452     case FlowColumn:
1453         m_value.valueID = CSSValueColumn;
1454         break;
1455     case FlowColumnReverse:
1456         m_value.valueID = CSSValueColumnReverse;
1457         break;
1458     }
1459 }
1460
1461 template<> inline CSSPrimitiveValue::operator EFlexDirection() const
1462 {
1463     ASSERT(isValueID());
1464
1465     switch (m_value.valueID) {
1466     case CSSValueRow:
1467         return FlowRow;
1468     case CSSValueRowReverse:
1469         return FlowRowReverse;
1470     case CSSValueColumn:
1471         return FlowColumn;
1472     case CSSValueColumnReverse:
1473         return FlowColumnReverse;
1474     default:
1475         break;
1476     }
1477
1478     ASSERT_NOT_REACHED();
1479     return FlowRow;
1480 }
1481
1482 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EAlignContent e)
1483     : CSSValue(PrimitiveClass)
1484 {
1485     m_primitiveUnitType = CSS_VALUE_ID;
1486     switch (e) {
1487     case AlignContentFlexStart:
1488         m_value.valueID = CSSValueFlexStart;
1489         break;
1490     case AlignContentFlexEnd:
1491         m_value.valueID = CSSValueFlexEnd;
1492         break;
1493     case AlignContentCenter:
1494         m_value.valueID = CSSValueCenter;
1495         break;
1496     case AlignContentSpaceBetween:
1497         m_value.valueID = CSSValueSpaceBetween;
1498         break;
1499     case AlignContentSpaceAround:
1500         m_value.valueID = CSSValueSpaceAround;
1501         break;
1502     case AlignContentStretch:
1503         m_value.valueID = CSSValueStretch;
1504         break;
1505     }
1506 }
1507
1508 template<> inline CSSPrimitiveValue::operator EAlignContent() const
1509 {
1510     ASSERT(isValueID());
1511
1512     switch (m_value.valueID) {
1513     case CSSValueFlexStart:
1514         return AlignContentFlexStart;
1515     case CSSValueFlexEnd:
1516         return AlignContentFlexEnd;
1517     case CSSValueCenter:
1518         return AlignContentCenter;
1519     case CSSValueSpaceBetween:
1520         return AlignContentSpaceBetween;
1521     case CSSValueSpaceAround:
1522         return AlignContentSpaceAround;
1523     case CSSValueStretch:
1524         return AlignContentStretch;
1525     default:
1526         break;
1527     }
1528
1529     ASSERT_NOT_REACHED();
1530     return AlignContentStretch;
1531 }
1532
1533 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFlexWrap e)
1534     : CSSValue(PrimitiveClass)
1535 {
1536     m_primitiveUnitType = CSS_VALUE_ID;
1537     switch (e) {
1538     case FlexNoWrap:
1539         m_value.valueID = CSSValueNowrap;
1540         break;
1541     case FlexWrap:
1542         m_value.valueID = CSSValueWrap;
1543         break;
1544     case FlexWrapReverse:
1545         m_value.valueID = CSSValueWrapReverse;
1546         break;
1547     }
1548 }
1549
1550 template<> inline CSSPrimitiveValue::operator EFlexWrap() const
1551 {
1552     ASSERT(isValueID());
1553
1554     switch (m_value.valueID) {
1555     case CSSValueNowrap:
1556         return FlexNoWrap;
1557     case CSSValueWrap:
1558         return FlexWrap;
1559     case CSSValueWrapReverse:
1560         return FlexWrapReverse;
1561     default:
1562         break;
1563     }
1564
1565     ASSERT_NOT_REACHED();
1566     return FlexNoWrap;
1567 }
1568
1569 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFloat e)
1570     : CSSValue(PrimitiveClass)
1571 {
1572     m_primitiveUnitType = CSS_VALUE_ID;
1573     switch (e) {
1574     case NoFloat:
1575         m_value.valueID = CSSValueNone;
1576         break;
1577     case LeftFloat:
1578         m_value.valueID = CSSValueLeft;
1579         break;
1580     case RightFloat:
1581         m_value.valueID = CSSValueRight;
1582         break;
1583     }
1584 }
1585
1586 template<> inline CSSPrimitiveValue::operator EFloat() const
1587 {
1588     ASSERT(isValueID());
1589
1590     switch (m_value.valueID) {
1591     case CSSValueLeft:
1592         return LeftFloat;
1593     case CSSValueRight:
1594         return RightFloat;
1595     case CSSValueNone:
1596     case CSSValueCenter: // Non-standard CSS value.
1597         return NoFloat;
1598     default:
1599         break;
1600     }
1601
1602     ASSERT_NOT_REACHED();
1603     return NoFloat;
1604 }
1605
1606 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineBreak e)
1607     : CSSValue(PrimitiveClass)
1608 {
1609     m_primitiveUnitType = CSS_VALUE_ID;
1610     switch (e) {
1611     case LineBreakAuto:
1612         m_value.valueID = CSSValueAuto;
1613         break;
1614     case LineBreakLoose:
1615         m_value.valueID = CSSValueLoose;
1616         break;
1617     case LineBreakNormal:
1618         m_value.valueID = CSSValueNormal;
1619         break;
1620     case LineBreakStrict:
1621         m_value.valueID = CSSValueStrict;
1622         break;
1623     case LineBreakAfterWhiteSpace:
1624         m_value.valueID = CSSValueAfterWhiteSpace;
1625         break;
1626     }
1627 }
1628
1629 template<> inline CSSPrimitiveValue::operator LineBreak() const
1630 {
1631     ASSERT(isValueID());
1632
1633     switch (m_value.valueID) {
1634     case CSSValueAuto:
1635         return LineBreakAuto;
1636     case CSSValueLoose:
1637         return LineBreakLoose;
1638     case CSSValueNormal:
1639         return LineBreakNormal;
1640     case CSSValueStrict:
1641         return LineBreakStrict;
1642     case CSSValueAfterWhiteSpace:
1643         return LineBreakAfterWhiteSpace;
1644     default:
1645         break;
1646     }
1647
1648     ASSERT_NOT_REACHED();
1649     return LineBreakAuto;
1650 }
1651
1652 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EListStylePosition e)
1653     : CSSValue(PrimitiveClass)
1654 {
1655     m_primitiveUnitType = CSS_VALUE_ID;
1656     switch (e) {
1657     case OUTSIDE:
1658         m_value.valueID = CSSValueOutside;
1659         break;
1660     case INSIDE:
1661         m_value.valueID = CSSValueInside;
1662         break;
1663     }
1664 }
1665
1666 template<> inline CSSPrimitiveValue::operator EListStylePosition() const
1667 {
1668     ASSERT(isValueID());
1669
1670     switch (m_value.valueID) {
1671     case CSSValueOutside:
1672         return OUTSIDE;
1673     case CSSValueInside:
1674         return INSIDE;
1675     default:
1676         break;
1677     }
1678
1679     ASSERT_NOT_REACHED();
1680     return OUTSIDE;
1681 }
1682
1683 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EListStyleType e)
1684     : CSSValue(PrimitiveClass)
1685 {
1686     m_primitiveUnitType = CSS_VALUE_ID;
1687     switch (e) {
1688     case Afar:
1689         m_value.valueID = CSSValueAfar;
1690         break;
1691     case Amharic:
1692         m_value.valueID = CSSValueAmharic;
1693         break;
1694     case AmharicAbegede:
1695         m_value.valueID = CSSValueAmharicAbegede;
1696         break;
1697     case ArabicIndic:
1698         m_value.valueID = CSSValueArabicIndic;
1699         break;
1700     case Armenian:
1701         m_value.valueID = CSSValueArmenian;
1702         break;
1703     case Asterisks:
1704         m_value.valueID = CSSValueAsterisks;
1705         break;
1706     case BinaryListStyle:
1707         m_value.valueID = CSSValueBinary;
1708         break;
1709     case Bengali:
1710         m_value.valueID = CSSValueBengali;
1711         break;
1712     case Cambodian:
1713         m_value.valueID = CSSValueCambodian;
1714         break;
1715     case Circle:
1716         m_value.valueID = CSSValueCircle;
1717         break;
1718     case CjkEarthlyBranch:
1719         m_value.valueID = CSSValueCjkEarthlyBranch;
1720         break;
1721     case CjkHeavenlyStem:
1722         m_value.valueID = CSSValueCjkHeavenlyStem;
1723         break;
1724     case CJKIdeographic:
1725         m_value.valueID = CSSValueCjkIdeographic;
1726         break;
1727     case DecimalLeadingZero:
1728         m_value.valueID = CSSValueDecimalLeadingZero;
1729         break;
1730     case DecimalListStyle:
1731         m_value.valueID = CSSValueDecimal;
1732         break;
1733     case Devanagari:
1734         m_value.valueID = CSSValueDevanagari;
1735         break;
1736     case Disc:
1737         m_value.valueID = CSSValueDisc;
1738         break;
1739     case Ethiopic:
1740         m_value.valueID = CSSValueEthiopic;
1741         break;
1742     case EthiopicAbegede:
1743         m_value.valueID = CSSValueEthiopicAbegede;
1744         break;
1745     case EthiopicAbegedeAmEt:
1746         m_value.valueID = CSSValueEthiopicAbegedeAmEt;
1747         break;
1748     case EthiopicAbegedeGez:
1749         m_value.valueID = CSSValueEthiopicAbegedeGez;
1750         break;
1751     case EthiopicAbegedeTiEr:
1752         m_value.valueID = CSSValueEthiopicAbegedeTiEr;
1753         break;
1754     case EthiopicAbegedeTiEt:
1755         m_value.valueID = CSSValueEthiopicAbegedeTiEt;
1756         break;
1757     case EthiopicHalehameAaEr:
1758         m_value.valueID = CSSValueEthiopicHalehameAaEr;
1759         break;
1760     case EthiopicHalehameAaEt:
1761         m_value.valueID = CSSValueEthiopicHalehameAaEt;
1762         break;
1763     case EthiopicHalehameAmEt:
1764         m_value.valueID = CSSValueEthiopicHalehameAmEt;
1765         break;
1766     case EthiopicHalehameGez:
1767         m_value.valueID = CSSValueEthiopicHalehameGez;
1768         break;
1769     case EthiopicHalehameOmEt:
1770         m_value.valueID = CSSValueEthiopicHalehameOmEt;
1771         break;
1772     case EthiopicHalehameSidEt:
1773         m_value.valueID = CSSValueEthiopicHalehameSidEt;
1774         break;
1775     case EthiopicHalehameSoEt:
1776         m_value.valueID = CSSValueEthiopicHalehameSoEt;
1777         break;
1778     case EthiopicHalehameTiEr:
1779         m_value.valueID = CSSValueEthiopicHalehameTiEr;
1780         break;
1781     case EthiopicHalehameTiEt:
1782         m_value.valueID = CSSValueEthiopicHalehameTiEt;
1783         break;
1784     case EthiopicHalehameTig:
1785         m_value.valueID = CSSValueEthiopicHalehameTig;
1786         break;
1787     case Footnotes:
1788         m_value.valueID = CSSValueFootnotes;
1789         break;
1790     case Georgian:
1791         m_value.valueID = CSSValueGeorgian;
1792         break;
1793     case Gujarati:
1794         m_value.valueID = CSSValueGujarati;
1795         break;
1796     case Gurmukhi:
1797         m_value.valueID = CSSValueGurmukhi;
1798         break;
1799     case Hangul:
1800         m_value.valueID = CSSValueHangul;
1801         break;
1802     case HangulConsonant:
1803         m_value.valueID = CSSValueHangulConsonant;
1804         break;
1805     case Hebrew:
1806         m_value.valueID = CSSValueHebrew;
1807         break;
1808     case Hiragana:
1809         m_value.valueID = CSSValueHiragana;
1810         break;
1811     case HiraganaIroha:
1812         m_value.valueID = CSSValueHiraganaIroha;
1813         break;
1814     case Kannada:
1815         m_value.valueID = CSSValueKannada;
1816         break;
1817     case Katakana:
1818         m_value.valueID = CSSValueKatakana;
1819         break;
1820     case KatakanaIroha:
1821         m_value.valueID = CSSValueKatakanaIroha;
1822         break;
1823     case Khmer:
1824         m_value.valueID = CSSValueKhmer;
1825         break;
1826     case Lao:
1827         m_value.valueID = CSSValueLao;
1828         break;
1829     case LowerAlpha:
1830         m_value.valueID = CSSValueLowerAlpha;
1831         break;
1832     case LowerArmenian:
1833         m_value.valueID = CSSValueLowerArmenian;
1834         break;
1835     case LowerGreek:
1836         m_value.valueID = CSSValueLowerGreek;
1837         break;
1838     case LowerHexadecimal:
1839         m_value.valueID = CSSValueLowerHexadecimal;
1840         break;
1841     case LowerLatin:
1842         m_value.valueID = CSSValueLowerLatin;
1843         break;
1844     case LowerNorwegian:
1845         m_value.valueID = CSSValueLowerNorwegian;
1846         break;
1847     case LowerRoman:
1848         m_value.valueID = CSSValueLowerRoman;
1849         break;
1850     case Malayalam:
1851         m_value.valueID = CSSValueMalayalam;
1852         break;
1853     case Mongolian:
1854         m_value.valueID = CSSValueMongolian;
1855         break;
1856     case Myanmar:
1857         m_value.valueID = CSSValueMyanmar;
1858         break;
1859     case NoneListStyle:
1860         m_value.valueID = CSSValueNone;
1861         break;
1862     case Octal:
1863         m_value.valueID = CSSValueOctal;
1864         break;
1865     case Oriya:
1866         m_value.valueID = CSSValueOriya;
1867         break;
1868     case Oromo:
1869         m_value.valueID = CSSValueOromo;
1870         break;
1871     case Persian:
1872         m_value.valueID = CSSValuePersian;
1873         break;
1874     case Sidama:
1875         m_value.valueID = CSSValueSidama;
1876         break;
1877     case Somali:
1878         m_value.valueID = CSSValueSomali;
1879         break;
1880     case Square:
1881         m_value.valueID = CSSValueSquare;
1882         break;
1883     case Telugu:
1884         m_value.valueID = CSSValueTelugu;
1885         break;
1886     case Thai:
1887         m_value.valueID = CSSValueThai;
1888         break;
1889     case Tibetan:
1890         m_value.valueID = CSSValueTibetan;
1891         break;
1892     case Tigre:
1893         m_value.valueID = CSSValueTigre;
1894         break;
1895     case TigrinyaEr:
1896         m_value.valueID = CSSValueTigrinyaEr;
1897         break;
1898     case TigrinyaErAbegede:
1899         m_value.valueID = CSSValueTigrinyaErAbegede;
1900         break;
1901     case TigrinyaEt:
1902         m_value.valueID = CSSValueTigrinyaEt;
1903         break;
1904     case TigrinyaEtAbegede:
1905         m_value.valueID = CSSValueTigrinyaEtAbegede;
1906         break;
1907     case UpperAlpha:
1908         m_value.valueID = CSSValueUpperAlpha;
1909         break;
1910     case UpperArmenian:
1911         m_value.valueID = CSSValueUpperArmenian;
1912         break;
1913     case UpperGreek:
1914         m_value.valueID = CSSValueUpperGreek;
1915         break;
1916     case UpperHexadecimal:
1917         m_value.valueID = CSSValueUpperHexadecimal;
1918         break;
1919     case UpperLatin:
1920         m_value.valueID = CSSValueUpperLatin;
1921         break;
1922     case UpperNorwegian:
1923         m_value.valueID = CSSValueUpperNorwegian;
1924         break;
1925     case UpperRoman:
1926         m_value.valueID = CSSValueUpperRoman;
1927         break;
1928     case Urdu:
1929         m_value.valueID = CSSValueUrdu;
1930         break;
1931     }
1932 }
1933
1934 template<> inline CSSPrimitiveValue::operator EListStyleType() const
1935 {
1936     ASSERT(isValueID());
1937
1938     switch (m_value.valueID) {
1939     case CSSValueNone:
1940         return NoneListStyle;
1941     default:
1942         return static_cast<EListStyleType>(m_value.valueID - CSSValueDisc);
1943     }
1944 }
1945
1946 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EMarginCollapse e)
1947     : CSSValue(PrimitiveClass)
1948 {
1949     m_primitiveUnitType = CSS_VALUE_ID;
1950     switch (e) {
1951     case MCOLLAPSE:
1952         m_value.valueID = CSSValueCollapse;
1953         break;
1954     case MSEPARATE:
1955         m_value.valueID = CSSValueSeparate;
1956         break;
1957     case MDISCARD:
1958         m_value.valueID = CSSValueDiscard;
1959         break;
1960     }
1961 }
1962
1963 template<> inline CSSPrimitiveValue::operator EMarginCollapse() const
1964 {
1965     ASSERT(isValueID());
1966
1967     switch (m_value.valueID) {
1968     case CSSValueCollapse:
1969         return MCOLLAPSE;
1970     case CSSValueSeparate:
1971         return MSEPARATE;
1972     case CSSValueDiscard:
1973         return MDISCARD;
1974     default:
1975         break;
1976     }
1977
1978     ASSERT_NOT_REACHED();
1979     return MCOLLAPSE;
1980 }
1981
1982 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EMarqueeBehavior e)
1983     : CSSValue(PrimitiveClass)
1984 {
1985     m_primitiveUnitType = CSS_VALUE_ID;
1986     switch (e) {
1987     case MNONE:
1988         m_value.valueID = CSSValueNone;
1989         break;
1990     case MSCROLL:
1991         m_value.valueID = CSSValueScroll;
1992         break;
1993     case MSLIDE:
1994         m_value.valueID = CSSValueSlide;
1995         break;
1996     case MALTERNATE:
1997         m_value.valueID = CSSValueAlternate;
1998         break;
1999     }
2000 }
2001
2002 template<> inline CSSPrimitiveValue::operator EMarqueeBehavior() const
2003 {
2004     ASSERT(isValueID());
2005
2006     switch (m_value.valueID) {
2007     case CSSValueNone:
2008         return MNONE;
2009     case CSSValueScroll:
2010         return MSCROLL;
2011     case CSSValueSlide:
2012         return MSLIDE;
2013     case CSSValueAlternate:
2014         return MALTERNATE;
2015     default:
2016         break;
2017     }
2018
2019     ASSERT_NOT_REACHED();
2020     return MNONE;
2021 }
2022
2023 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(RegionFragment e)
2024     : CSSValue(PrimitiveClass)
2025 {
2026     m_primitiveUnitType = CSS_VALUE_ID;
2027     switch (e) {
2028     case AutoRegionFragment:
2029         m_value.valueID = CSSValueAuto;
2030         break;
2031     case BreakRegionFragment:
2032         m_value.valueID = CSSValueBreak;
2033         break;
2034     }
2035 }
2036
2037 template<> inline CSSPrimitiveValue::operator RegionFragment() const
2038 {
2039     ASSERT(isValueID());
2040
2041     switch (m_value.valueID) {
2042     case CSSValueAuto:
2043         return AutoRegionFragment;
2044     case CSSValueBreak:
2045         return BreakRegionFragment;
2046     default:
2047         break;
2048     }
2049
2050     ASSERT_NOT_REACHED();
2051     return AutoRegionFragment;
2052 }
2053
2054 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EMarqueeDirection e)
2055     : CSSValue(PrimitiveClass)
2056 {
2057     m_primitiveUnitType = CSS_VALUE_ID;
2058     switch (e) {
2059     case MFORWARD:
2060         m_value.valueID = CSSValueForwards;
2061         break;
2062     case MBACKWARD:
2063         m_value.valueID = CSSValueBackwards;
2064         break;
2065     case MAUTO:
2066         m_value.valueID = CSSValueAuto;
2067         break;
2068     case MUP:
2069         m_value.valueID = CSSValueUp;
2070         break;
2071     case MDOWN:
2072         m_value.valueID = CSSValueDown;
2073         break;
2074     case MLEFT:
2075         m_value.valueID = CSSValueLeft;
2076         break;
2077     case MRIGHT:
2078         m_value.valueID = CSSValueRight;
2079         break;
2080     }
2081 }
2082
2083 template<> inline CSSPrimitiveValue::operator EMarqueeDirection() const
2084 {
2085     ASSERT(isValueID());
2086
2087     switch (m_value.valueID) {
2088     case CSSValueForwards:
2089         return MFORWARD;
2090     case CSSValueBackwards:
2091         return MBACKWARD;
2092     case CSSValueAuto:
2093         return MAUTO;
2094     case CSSValueAhead:
2095     case CSSValueUp: // We don't support vertical languages, so AHEAD just maps to UP.
2096         return MUP;
2097     case CSSValueReverse:
2098     case CSSValueDown: // REVERSE just maps to DOWN, since we don't do vertical text.
2099         return MDOWN;
2100     case CSSValueLeft:
2101         return MLEFT;
2102     case CSSValueRight:
2103         return MRIGHT;
2104     default:
2105         break;
2106     }
2107
2108     ASSERT_NOT_REACHED();
2109     return MAUTO;
2110 }
2111
2112 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ENBSPMode e)
2113     : CSSValue(PrimitiveClass)
2114 {
2115     m_primitiveUnitType = CSS_VALUE_ID;
2116     switch (e) {
2117     case NBNORMAL:
2118         m_value.valueID = CSSValueNormal;
2119         break;
2120     case SPACE:
2121         m_value.valueID = CSSValueSpace;
2122         break;
2123     }
2124 }
2125
2126 template<> inline CSSPrimitiveValue::operator ENBSPMode() const
2127 {
2128     ASSERT(isValueID());
2129
2130     switch (m_value.valueID) {
2131     case CSSValueSpace:
2132         return SPACE;
2133     case CSSValueNormal:
2134         return NBNORMAL;
2135     default:
2136         break;
2137     }
2138
2139     ASSERT_NOT_REACHED();
2140     return NBNORMAL;
2141 }
2142
2143 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EOverflow e)
2144     : CSSValue(PrimitiveClass)
2145 {
2146     m_primitiveUnitType = CSS_VALUE_ID;
2147     switch (e) {
2148     case OVISIBLE:
2149         m_value.valueID = CSSValueVisible;
2150         break;
2151     case OHIDDEN:
2152         m_value.valueID = CSSValueHidden;
2153         break;
2154     case OSCROLL:
2155         m_value.valueID = CSSValueScroll;
2156         break;
2157     case OAUTO:
2158         m_value.valueID = CSSValueAuto;
2159         break;
2160     case OMARQUEE:
2161         m_value.valueID = CSSValueWebkitMarquee;
2162         break;
2163     case OOVERLAY:
2164         m_value.valueID = CSSValueOverlay;
2165         break;
2166     case OPAGEDX:
2167         m_value.valueID = CSSValueWebkitPagedX;
2168         break;
2169     case OPAGEDY:
2170         m_value.valueID = CSSValueWebkitPagedY;
2171         break;
2172     }
2173 }
2174
2175 template<> inline CSSPrimitiveValue::operator EOverflow() const
2176 {
2177     ASSERT(isValueID());
2178
2179     switch (m_value.valueID) {
2180     case CSSValueVisible:
2181         return OVISIBLE;
2182     case CSSValueHidden:
2183         return OHIDDEN;
2184     case CSSValueScroll:
2185         return OSCROLL;
2186     case CSSValueAuto:
2187         return OAUTO;
2188     case CSSValueWebkitMarquee:
2189         return OMARQUEE;
2190     case CSSValueOverlay:
2191         return OOVERLAY;
2192     case CSSValueWebkitPagedX:
2193         return OPAGEDX;
2194     case CSSValueWebkitPagedY:
2195         return OPAGEDY;
2196     default:
2197         break;
2198     }
2199
2200     ASSERT_NOT_REACHED();
2201     return OVISIBLE;
2202 }
2203
2204 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(BreakBetween e)
2205     : CSSValue(PrimitiveClass)
2206 {
2207     m_primitiveUnitType = CSS_VALUE_ID;
2208     switch (e) {
2209     case AutoBreakBetween:
2210         m_value.valueID = CSSValueAuto;
2211         break;
2212     case AvoidBreakBetween:
2213         m_value.valueID = CSSValueAvoid;
2214         break;
2215     case AvoidColumnBreakBetween:
2216         m_value.valueID = CSSValueAvoidColumn;
2217         break;
2218     case AvoidPageBreakBetween:
2219         m_value.valueID = CSSValueAvoidPage;
2220         break;
2221     case AvoidRegionBreakBetween:
2222         m_value.valueID = CSSValueAvoidRegion;
2223         break;
2224     case ColumnBreakBetween:
2225         m_value.valueID = CSSValueColumn;
2226         break;
2227     case PageBreakBetween:
2228         m_value.valueID = CSSValuePage;
2229         break;
2230     case RegionBreakBetween:
2231         m_value.valueID = CSSValueRegion;
2232         break;
2233     case LeftPageBreakBetween:
2234         m_value.valueID = CSSValueLeft;
2235         break;
2236     case RightPageBreakBetween:
2237         m_value.valueID = CSSValueRight;
2238         break;
2239     case RectoPageBreakBetween:
2240         m_value.valueID = CSSValueRecto;
2241         break;
2242     case VersoPageBreakBetween:
2243         m_value.valueID = CSSValueVerso;
2244         break;
2245     }
2246 }
2247
2248 template<> inline CSSPrimitiveValue::operator BreakBetween() const
2249 {
2250     ASSERT(isValueID());
2251
2252     switch (m_value.valueID) {
2253     case CSSValueAuto:
2254         return AutoBreakBetween;
2255     case CSSValueAvoid:
2256         return AvoidBreakBetween;
2257     case CSSValueAvoidColumn:
2258         return AvoidColumnBreakBetween;
2259     case CSSValueAvoidPage:
2260         return AvoidPageBreakBetween;
2261     case CSSValueAvoidRegion:
2262         return AvoidRegionBreakBetween;
2263     case CSSValueColumn:
2264         return ColumnBreakBetween;
2265     case CSSValuePage:
2266         return PageBreakBetween;
2267     case CSSValueRegion:
2268         return RegionBreakBetween;
2269     case CSSValueLeft:
2270         return LeftPageBreakBetween;
2271     case CSSValueRight:
2272         return RightPageBreakBetween;
2273     case CSSValueRecto:
2274         return RectoPageBreakBetween;
2275     case CSSValueVerso:
2276         return VersoPageBreakBetween;
2277     default:
2278         break;
2279     }
2280
2281     ASSERT_NOT_REACHED();
2282     return AutoBreakBetween;
2283 }
2284
2285 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(BreakInside e)
2286     : CSSValue(PrimitiveClass)
2287 {
2288     m_primitiveUnitType = CSS_VALUE_ID;
2289     switch (e) {
2290     case AutoBreakInside:
2291         m_value.valueID = CSSValueAuto;
2292         break;
2293     case AvoidBreakInside:
2294         m_value.valueID = CSSValueAvoid;
2295         break;
2296     case AvoidColumnBreakInside:
2297         m_value.valueID = CSSValueAvoidColumn;
2298         break;
2299     case AvoidPageBreakInside:
2300         m_value.valueID = CSSValueAvoidPage;
2301         break;
2302     case AvoidRegionBreakInside:
2303         m_value.valueID = CSSValueAvoidRegion;
2304         break;
2305     }
2306 }
2307
2308 template<> inline CSSPrimitiveValue::operator BreakInside() const
2309 {
2310     ASSERT(isValueID());
2311     
2312     switch (m_value.valueID) {
2313     case CSSValueAuto:
2314         return AutoBreakInside;
2315     case CSSValueAvoid:
2316         return AvoidBreakInside;
2317     case CSSValueAvoidColumn:
2318         return AvoidColumnBreakInside;
2319     case CSSValueAvoidPage:
2320         return AvoidPageBreakInside;
2321     case CSSValueAvoidRegion:
2322         return AvoidRegionBreakInside;
2323     default:
2324         break;
2325     }
2326
2327     ASSERT_NOT_REACHED();
2328     return AutoBreakInside;
2329 }
2330
2331 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EPosition e)
2332     : CSSValue(PrimitiveClass)
2333 {
2334     m_primitiveUnitType = CSS_VALUE_ID;
2335     switch (e) {
2336     case StaticPosition:
2337         m_value.valueID = CSSValueStatic;
2338         break;
2339     case RelativePosition:
2340         m_value.valueID = CSSValueRelative;
2341         break;
2342     case AbsolutePosition:
2343         m_value.valueID = CSSValueAbsolute;
2344         break;
2345     case FixedPosition:
2346         m_value.valueID = CSSValueFixed;
2347         break;
2348     case StickyPosition:
2349         m_value.valueID = CSSValueWebkitSticky;
2350         break;
2351     }
2352 }
2353
2354 template<> inline CSSPrimitiveValue::operator EPosition() const
2355 {
2356     ASSERT(isValueID());
2357
2358     switch (m_value.valueID) {
2359     case CSSValueStatic:
2360         return StaticPosition;
2361     case CSSValueRelative:
2362         return RelativePosition;
2363     case CSSValueAbsolute:
2364         return AbsolutePosition;
2365     case CSSValueFixed:
2366         return FixedPosition;
2367     case CSSValueWebkitSticky:
2368         return StickyPosition;
2369     default:
2370         break;
2371     }
2372
2373     ASSERT_NOT_REACHED();
2374     return StaticPosition;
2375 }
2376
2377 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EResize e)
2378     : CSSValue(PrimitiveClass)
2379 {
2380     m_primitiveUnitType = CSS_VALUE_ID;
2381     switch (e) {
2382     case RESIZE_BOTH:
2383         m_value.valueID = CSSValueBoth;
2384         break;
2385     case RESIZE_HORIZONTAL:
2386         m_value.valueID = CSSValueHorizontal;
2387         break;
2388     case RESIZE_VERTICAL:
2389         m_value.valueID = CSSValueVertical;
2390         break;
2391     case RESIZE_NONE:
2392         m_value.valueID = CSSValueNone;
2393         break;
2394     }
2395 }
2396
2397 template<> inline CSSPrimitiveValue::operator EResize() const
2398 {
2399     ASSERT(isValueID());
2400
2401     switch (m_value.valueID) {
2402     case CSSValueBoth:
2403         return RESIZE_BOTH;
2404     case CSSValueHorizontal:
2405         return RESIZE_HORIZONTAL;
2406     case CSSValueVertical:
2407         return RESIZE_VERTICAL;
2408     case CSSValueAuto:
2409         ASSERT_NOT_REACHED(); // Depends on settings, thus should be handled by the caller.
2410         return RESIZE_NONE;
2411     case CSSValueNone:
2412         return RESIZE_NONE;
2413     default:
2414         break;
2415     }
2416
2417     ASSERT_NOT_REACHED();
2418     return RESIZE_NONE;
2419 }
2420
2421 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETableLayout e)
2422     : CSSValue(PrimitiveClass)
2423 {
2424     m_primitiveUnitType = CSS_VALUE_ID;
2425     switch (e) {
2426     case TAUTO:
2427         m_value.valueID = CSSValueAuto;
2428         break;
2429     case TFIXED:
2430         m_value.valueID = CSSValueFixed;
2431         break;
2432     }
2433 }
2434
2435 template<> inline CSSPrimitiveValue::operator ETableLayout() const
2436 {
2437     ASSERT(isValueID());
2438
2439     switch (m_value.valueID) {
2440     case CSSValueFixed:
2441         return TFIXED;
2442     case CSSValueAuto:
2443         return TAUTO;
2444     default:
2445         break;
2446     }
2447
2448     ASSERT_NOT_REACHED();
2449     return TAUTO;
2450 }
2451
2452 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETextAlign e)
2453     : CSSValue(PrimitiveClass)
2454 {
2455     m_primitiveUnitType = CSS_VALUE_ID;
2456     switch (e) {
2457     case TASTART:
2458         m_value.valueID = CSSValueStart;
2459         break;
2460     case TAEND:
2461         m_value.valueID = CSSValueEnd;
2462         break;
2463     case LEFT:
2464         m_value.valueID = CSSValueLeft;
2465         break;
2466     case RIGHT:
2467         m_value.valueID = CSSValueRight;
2468         break;
2469     case CENTER:
2470         m_value.valueID = CSSValueCenter;
2471         break;
2472     case JUSTIFY:
2473         m_value.valueID = CSSValueJustify;
2474         break;
2475     case WEBKIT_LEFT:
2476         m_value.valueID = CSSValueWebkitLeft;
2477         break;
2478     case WEBKIT_RIGHT:
2479         m_value.valueID = CSSValueWebkitRight;
2480         break;
2481     case WEBKIT_CENTER:
2482         m_value.valueID = CSSValueWebkitCenter;
2483         break;
2484     }
2485 }
2486
2487 template<> inline CSSPrimitiveValue::operator ETextAlign() const
2488 {
2489     ASSERT(isValueID());
2490
2491     switch (m_value.valueID) {
2492     case CSSValueWebkitAuto: // Legacy -webkit-auto. Eqiuvalent to start.
2493     case CSSValueStart:
2494         return TASTART;
2495     case CSSValueEnd:
2496         return TAEND;
2497     default:
2498         return static_cast<ETextAlign>(m_value.valueID - CSSValueLeft);
2499     }
2500 }
2501
2502 #if ENABLE(CSS3_TEXT)
2503 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextAlignLast e)
2504     : CSSValue(PrimitiveClass)
2505 {
2506     m_primitiveUnitType = CSS_VALUE_ID;
2507     switch (e) {
2508     case TextAlignLastStart:
2509         m_value.valueID = CSSValueStart;
2510         break;
2511     case TextAlignLastEnd:
2512         m_value.valueID = CSSValueEnd;
2513         break;
2514     case TextAlignLastLeft:
2515         m_value.valueID = CSSValueLeft;
2516         break;
2517     case TextAlignLastRight:
2518         m_value.valueID = CSSValueRight;
2519         break;
2520     case TextAlignLastCenter:
2521         m_value.valueID = CSSValueCenter;
2522         break;
2523     case TextAlignLastJustify:
2524         m_value.valueID = CSSValueJustify;
2525         break;
2526     case TextAlignLastAuto:
2527         m_value.valueID = CSSValueAuto;
2528         break;
2529     }
2530 }
2531
2532 template<> inline CSSPrimitiveValue::operator TextAlignLast() const
2533 {
2534     ASSERT(isValueID());
2535
2536     switch (m_value.valueID) {
2537     case CSSValueAuto:
2538         return TextAlignLastAuto;
2539     case CSSValueStart:
2540         return TextAlignLastStart;
2541     case CSSValueEnd:
2542         return TextAlignLastEnd;
2543     case CSSValueLeft:
2544         return TextAlignLastLeft;
2545     case CSSValueRight:
2546         return TextAlignLastRight;
2547     case CSSValueCenter:
2548         return TextAlignLastCenter;
2549     case CSSValueJustify:
2550         return TextAlignLastJustify;
2551     default:
2552         break;
2553     }
2554
2555     ASSERT_NOT_REACHED();
2556     return TextAlignLastAuto;
2557 }
2558
2559 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextJustify e)
2560     : CSSValue(PrimitiveClass)
2561 {
2562     m_primitiveUnitType = CSS_VALUE_ID;
2563     switch (e) {
2564     case TextJustifyAuto:
2565         m_value.valueID = CSSValueAuto;
2566         break;
2567     case TextJustifyNone:
2568         m_value.valueID = CSSValueNone;
2569         break;
2570     case TextJustifyInterWord:
2571         m_value.valueID = CSSValueInterWord;
2572         break;
2573     case TextJustifyDistribute:
2574         m_value.valueID = CSSValueDistribute;
2575         break;
2576     }
2577 }
2578
2579 template<> inline CSSPrimitiveValue::operator TextJustify() const
2580 {
2581     ASSERT(isValueID());
2582
2583     switch (m_value.valueID) {
2584     case CSSValueAuto:
2585         return TextJustifyAuto;
2586     case CSSValueNone:
2587         return TextJustifyNone;
2588     case CSSValueInterWord:
2589         return TextJustifyInterWord;
2590     case CSSValueDistribute:
2591         return TextJustifyDistribute;
2592     default:
2593         break;
2594     }
2595
2596     ASSERT_NOT_REACHED();
2597     return TextJustifyAuto;
2598 }
2599 #endif // CSS3_TEXT
2600
2601 template<> inline CSSPrimitiveValue::operator TextDecoration() const
2602 {
2603     ASSERT(isValueID());
2604
2605     switch (m_value.valueID) {
2606     case CSSValueNone:
2607         return TextDecorationNone;
2608     case CSSValueUnderline:
2609         return TextDecorationUnderline;
2610     case CSSValueOverline:
2611         return TextDecorationOverline;
2612     case CSSValueLineThrough:
2613         return TextDecorationLineThrough;
2614     case CSSValueBlink:
2615         return TextDecorationBlink;
2616 #if ENABLE(LETTERPRESS)
2617     case CSSValueWebkitLetterpress:
2618         return TextDecorationLetterpress;
2619 #endif
2620     default:
2621         break;
2622     }
2623
2624     ASSERT_NOT_REACHED();
2625     return TextDecorationNone;
2626 }
2627
2628 template<> inline CSSPrimitiveValue::operator TextDecorationStyle() const
2629 {
2630     ASSERT(isValueID());
2631
2632     switch (m_value.valueID) {
2633     case CSSValueSolid:
2634         return TextDecorationStyleSolid;
2635     case CSSValueDouble:
2636         return TextDecorationStyleDouble;
2637     case CSSValueDotted:
2638         return TextDecorationStyleDotted;
2639     case CSSValueDashed:
2640         return TextDecorationStyleDashed;
2641     case CSSValueWavy:
2642         return TextDecorationStyleWavy;
2643     default:
2644         break;
2645     }
2646
2647     ASSERT_NOT_REACHED();
2648     return TextDecorationStyleSolid;
2649 }
2650
2651 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextUnderlinePosition e)
2652     : CSSValue(PrimitiveClass)
2653 {
2654     m_primitiveUnitType = CSS_VALUE_ID;
2655     switch (e) {
2656     case TextUnderlinePositionAuto:
2657         m_value.valueID = CSSValueAuto;
2658         break;
2659     case TextUnderlinePositionAlphabetic:
2660         m_value.valueID = CSSValueAlphabetic;
2661         break;
2662     case TextUnderlinePositionUnder:
2663         m_value.valueID = CSSValueUnder;
2664         break;
2665     }
2666
2667     // FIXME: Implement support for 'under left' and 'under right' values.
2668 }
2669
2670 template<> inline CSSPrimitiveValue::operator TextUnderlinePosition() const
2671 {
2672     ASSERT(isValueID());
2673
2674     switch (m_value.valueID) {
2675     case CSSValueAuto:
2676         return TextUnderlinePositionAuto;
2677     case CSSValueAlphabetic:
2678         return TextUnderlinePositionAlphabetic;
2679     case CSSValueUnder:
2680         return TextUnderlinePositionUnder;
2681     default:
2682         break;
2683     }
2684
2685     // FIXME: Implement support for 'under left' and 'under right' values.
2686
2687     ASSERT_NOT_REACHED();
2688     return TextUnderlinePositionAuto;
2689 }
2690
2691 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETextSecurity e)
2692     : CSSValue(PrimitiveClass)
2693 {
2694     m_primitiveUnitType = CSS_VALUE_ID;
2695     switch (e) {
2696     case TSNONE:
2697         m_value.valueID = CSSValueNone;
2698         break;
2699     case TSDISC:
2700         m_value.valueID = CSSValueDisc;
2701         break;
2702     case TSCIRCLE:
2703         m_value.valueID = CSSValueCircle;
2704         break;
2705     case TSSQUARE:
2706         m_value.valueID = CSSValueSquare;
2707         break;
2708     }
2709 }
2710
2711 template<> inline CSSPrimitiveValue::operator ETextSecurity() const
2712 {
2713     ASSERT(isValueID());
2714
2715     switch (m_value.valueID) {
2716     case CSSValueNone:
2717         return TSNONE;
2718     case CSSValueDisc:
2719         return TSDISC;
2720     case CSSValueCircle:
2721         return TSCIRCLE;
2722     case CSSValueSquare:
2723         return TSSQUARE;
2724     default:
2725         break;
2726     }
2727
2728     ASSERT_NOT_REACHED();
2729     return TSNONE;
2730 }
2731
2732 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETextTransform e)
2733     : CSSValue(PrimitiveClass)
2734 {
2735     m_primitiveUnitType = CSS_VALUE_ID;
2736     switch (e) {
2737     case CAPITALIZE:
2738         m_value.valueID = CSSValueCapitalize;
2739         break;
2740     case UPPERCASE:
2741         m_value.valueID = CSSValueUppercase;
2742         break;
2743     case LOWERCASE:
2744         m_value.valueID = CSSValueLowercase;
2745         break;
2746     case TTNONE:
2747         m_value.valueID = CSSValueNone;
2748         break;
2749     }
2750 }
2751
2752 template<> inline CSSPrimitiveValue::operator ETextTransform() const
2753 {
2754     ASSERT(isValueID());
2755
2756     switch (m_value.valueID) {
2757     case CSSValueCapitalize:
2758         return CAPITALIZE;
2759     case CSSValueUppercase:
2760         return UPPERCASE;
2761     case CSSValueLowercase:
2762         return LOWERCASE;
2763     case CSSValueNone:
2764         return TTNONE;
2765     default:
2766         break;
2767     }
2768
2769     ASSERT_NOT_REACHED();
2770     return TTNONE;
2771 }
2772
2773 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUnicodeBidi e)
2774     : CSSValue(PrimitiveClass)
2775 {
2776     m_primitiveUnitType = CSS_VALUE_ID;
2777     switch (e) {
2778     case UBNormal:
2779         m_value.valueID = CSSValueNormal;
2780         break;
2781     case Embed:
2782         m_value.valueID = CSSValueEmbed;
2783         break;
2784     case Override:
2785         m_value.valueID = CSSValueBidiOverride;
2786         break;
2787     case Isolate:
2788         m_value.valueID = CSSValueWebkitIsolate;
2789         break;
2790     case IsolateOverride:
2791         m_value.valueID = CSSValueWebkitIsolateOverride;
2792         break;
2793     case Plaintext:
2794         m_value.valueID = CSSValueWebkitPlaintext;
2795         break;
2796     }
2797 }
2798
2799 template<> inline CSSPrimitiveValue::operator EUnicodeBidi() const
2800 {
2801     ASSERT(isValueID());
2802
2803     switch (m_value.valueID) {
2804     case CSSValueNormal:
2805         return UBNormal;
2806     case CSSValueEmbed:
2807         return Embed;
2808     case CSSValueBidiOverride:
2809         return Override;
2810     case CSSValueWebkitIsolate:
2811         return Isolate;
2812     case CSSValueWebkitIsolateOverride:
2813         return IsolateOverride;
2814     case CSSValueWebkitPlaintext:
2815         return Plaintext;
2816     default:
2817         break;
2818     }
2819
2820     ASSERT_NOT_REACHED();
2821     return UBNormal;
2822 }
2823
2824 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUserDrag e)
2825     : CSSValue(PrimitiveClass)
2826 {
2827     m_primitiveUnitType = CSS_VALUE_ID;
2828     switch (e) {
2829     case DRAG_AUTO:
2830         m_value.valueID = CSSValueAuto;
2831         break;
2832     case DRAG_NONE:
2833         m_value.valueID = CSSValueNone;
2834         break;
2835     case DRAG_ELEMENT:
2836         m_value.valueID = CSSValueElement;
2837         break;
2838     default:
2839         break;
2840     }
2841 }
2842
2843 template<> inline CSSPrimitiveValue::operator EUserDrag() const
2844 {
2845     ASSERT(isValueID());
2846
2847     switch (m_value.valueID) {
2848     case CSSValueAuto:
2849         return DRAG_AUTO;
2850     case CSSValueNone:
2851         return DRAG_NONE;
2852     case CSSValueElement:
2853         return DRAG_ELEMENT;
2854     default:
2855         break;
2856     }
2857
2858     ASSERT_NOT_REACHED();
2859     return DRAG_AUTO;
2860 }
2861
2862 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUserModify e)
2863     : CSSValue(PrimitiveClass)
2864 {
2865     m_primitiveUnitType = CSS_VALUE_ID;
2866     switch (e) {
2867     case READ_ONLY:
2868         m_value.valueID = CSSValueReadOnly;
2869         break;
2870     case READ_WRITE:
2871         m_value.valueID = CSSValueReadWrite;
2872         break;
2873     case READ_WRITE_PLAINTEXT_ONLY:
2874         m_value.valueID = CSSValueReadWritePlaintextOnly;
2875         break;
2876     }
2877 }
2878
2879 template<> inline CSSPrimitiveValue::operator EUserModify() const
2880 {
2881     ASSERT(isValueID());
2882
2883     switch (m_value.valueID) {
2884     case CSSValueReadOnly:
2885         return READ_ONLY;
2886     case CSSValueReadWrite:
2887         return READ_WRITE;
2888     case CSSValueReadWritePlaintextOnly:
2889         return READ_WRITE_PLAINTEXT_ONLY;
2890     default:
2891         break;
2892     }
2893
2894     ASSERT_NOT_REACHED();
2895     return READ_ONLY;
2896 }
2897
2898 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUserSelect e)
2899     : CSSValue(PrimitiveClass)
2900 {
2901     m_primitiveUnitType = CSS_VALUE_ID;
2902     switch (e) {
2903     case SELECT_NONE:
2904         m_value.valueID = CSSValueNone;
2905         break;
2906     case SELECT_TEXT:
2907         m_value.valueID = CSSValueText;
2908         break;
2909     case SELECT_ALL:
2910         m_value.valueID = CSSValueAll;
2911         break;
2912     }
2913 }
2914
2915 template<> inline CSSPrimitiveValue::operator EUserSelect() const
2916 {
2917     ASSERT(isValueID());
2918
2919     switch (m_value.valueID) {
2920     case CSSValueAuto:
2921         return SELECT_TEXT;
2922     case CSSValueNone:
2923         return SELECT_NONE;
2924     case CSSValueText:
2925         return SELECT_TEXT;
2926     case CSSValueAll:
2927         return SELECT_ALL;
2928     default:
2929         break;
2930     }
2931
2932     ASSERT_NOT_REACHED();
2933     return SELECT_TEXT;
2934 }
2935
2936 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EVerticalAlign a)
2937     : CSSValue(PrimitiveClass)
2938 {
2939     m_primitiveUnitType = CSS_VALUE_ID;
2940     switch (a) {
2941     case TOP:
2942         m_value.valueID = CSSValueTop;
2943         break;
2944     case BOTTOM:
2945         m_value.valueID = CSSValueBottom;
2946         break;
2947     case MIDDLE:
2948         m_value.valueID = CSSValueMiddle;
2949         break;
2950     case BASELINE:
2951         m_value.valueID = CSSValueBaseline;
2952         break;
2953     case TEXT_BOTTOM:
2954         m_value.valueID = CSSValueTextBottom;
2955         break;
2956     case TEXT_TOP:
2957         m_value.valueID = CSSValueTextTop;
2958         break;
2959     case SUB:
2960         m_value.valueID = CSSValueSub;
2961         break;
2962     case SUPER:
2963         m_value.valueID = CSSValueSuper;
2964         break;
2965     case BASELINE_MIDDLE:
2966         m_value.valueID = CSSValueWebkitBaselineMiddle;
2967         break;
2968     case LENGTH:
2969         m_value.valueID = CSSValueInvalid;
2970     }
2971 }
2972
2973 template<> inline CSSPrimitiveValue::operator EVerticalAlign() const
2974 {
2975     ASSERT(isValueID());
2976
2977     switch (m_value.valueID) {
2978     case CSSValueTop:
2979         return TOP;
2980     case CSSValueBottom:
2981         return BOTTOM;
2982     case CSSValueMiddle:
2983         return MIDDLE;
2984     case CSSValueBaseline:
2985         return BASELINE;
2986     case CSSValueTextBottom:
2987         return TEXT_BOTTOM;
2988     case CSSValueTextTop:
2989         return TEXT_TOP;
2990     case CSSValueSub:
2991         return SUB;
2992     case CSSValueSuper:
2993         return SUPER;
2994     case CSSValueWebkitBaselineMiddle:
2995         return BASELINE_MIDDLE;
2996     default:
2997         break;
2998     }
2999
3000     ASSERT_NOT_REACHED();
3001     return TOP;
3002 }
3003
3004 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EVisibility e)
3005     : CSSValue(PrimitiveClass)
3006 {
3007     m_primitiveUnitType = CSS_VALUE_ID;
3008     switch (e) {
3009     case VISIBLE:
3010         m_value.valueID = CSSValueVisible;
3011         break;
3012     case HIDDEN:
3013         m_value.valueID = CSSValueHidden;
3014         break;
3015     case COLLAPSE:
3016         m_value.valueID = CSSValueCollapse;
3017         break;
3018     }
3019 }
3020
3021 template<> inline CSSPrimitiveValue::operator EVisibility() const
3022 {
3023     ASSERT(isValueID());
3024
3025     switch (m_value.valueID) {
3026     case CSSValueHidden:
3027         return HIDDEN;
3028     case CSSValueVisible:
3029         return VISIBLE;
3030     case CSSValueCollapse:
3031         return COLLAPSE;
3032     default:
3033         break;
3034     }
3035
3036     ASSERT_NOT_REACHED();
3037     return VISIBLE;
3038 }
3039
3040 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EWhiteSpace e)
3041     : CSSValue(PrimitiveClass)
3042 {
3043     m_primitiveUnitType = CSS_VALUE_ID;
3044     switch (e) {
3045     case NORMAL:
3046         m_value.valueID = CSSValueNormal;
3047         break;
3048     case PRE:
3049         m_value.valueID = CSSValuePre;
3050         break;
3051     case PRE_WRAP:
3052         m_value.valueID = CSSValuePreWrap;
3053         break;
3054     case PRE_LINE:
3055         m_value.valueID = CSSValuePreLine;
3056         break;
3057     case NOWRAP:
3058         m_value.valueID = CSSValueNowrap;
3059         break;
3060     case KHTML_NOWRAP:
3061         m_value.valueID = CSSValueWebkitNowrap;
3062         break;
3063     }
3064 }
3065
3066 template<> inline CSSPrimitiveValue::operator EWhiteSpace() const
3067 {
3068     ASSERT(isValueID());
3069
3070     switch (m_value.valueID) {
3071     case CSSValueWebkitNowrap:
3072         return KHTML_NOWRAP;
3073     case CSSValueNowrap:
3074         return NOWRAP;
3075     case CSSValuePre:
3076         return PRE;
3077     case CSSValuePreWrap:
3078         return PRE_WRAP;
3079     case CSSValuePreLine:
3080         return PRE_LINE;
3081     case CSSValueNormal:
3082         return NORMAL;
3083     default:
3084         break;
3085     }
3086
3087     ASSERT_NOT_REACHED();
3088     return NORMAL;
3089 }
3090
3091 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EWordBreak e)
3092     : CSSValue(PrimitiveClass)
3093 {
3094     m_primitiveUnitType = CSS_VALUE_ID;
3095     switch (e) {
3096     case NormalWordBreak:
3097         m_value.valueID = CSSValueNormal;
3098         break;
3099     case BreakAllWordBreak:
3100         m_value.valueID = CSSValueBreakAll;
3101         break;
3102     case KeepAllWordBreak:
3103         m_value.valueID = CSSValueKeepAll;
3104         break;
3105     case BreakWordBreak:
3106         m_value.valueID = CSSValueBreakWord;
3107         break;
3108     }
3109 }
3110
3111 template<> inline CSSPrimitiveValue::operator EWordBreak() const
3112 {
3113     ASSERT(isValueID());
3114
3115     switch (m_value.valueID) {
3116     case CSSValueBreakAll:
3117         return BreakAllWordBreak;
3118     case CSSValueKeepAll:
3119         return KeepAllWordBreak;
3120     case CSSValueBreakWord:
3121         return BreakWordBreak;
3122     case CSSValueNormal:
3123         return NormalWordBreak;
3124     default:
3125         break;
3126     }
3127
3128     ASSERT_NOT_REACHED();
3129     return NormalWordBreak;
3130 }
3131
3132 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EOverflowWrap e)
3133     : CSSValue(PrimitiveClass)
3134 {
3135     m_primitiveUnitType = CSS_VALUE_ID;
3136     switch (e) {
3137     case NormalOverflowWrap:
3138         m_value.valueID = CSSValueNormal;
3139         break;
3140     case BreakOverflowWrap:
3141         m_value.valueID = CSSValueBreakWord;
3142         break;
3143     }
3144 }
3145
3146 template<> inline CSSPrimitiveValue::operator EOverflowWrap() const
3147 {
3148     ASSERT(isValueID());
3149
3150     switch (m_value.valueID) {
3151     case CSSValueBreakWord:
3152         return BreakOverflowWrap;
3153     case CSSValueNormal:
3154         return NormalOverflowWrap;
3155     default:
3156         break;
3157     }
3158
3159     ASSERT_NOT_REACHED();
3160     return NormalOverflowWrap;
3161 }
3162
3163 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextDirection e)
3164     : CSSValue(PrimitiveClass)
3165 {
3166     m_primitiveUnitType = CSS_VALUE_ID;
3167     switch (e) {
3168     case LTR:
3169         m_value.valueID = CSSValueLtr;
3170         break;
3171     case RTL:
3172         m_value.valueID = CSSValueRtl;
3173         break;
3174     }
3175 }
3176
3177 template<> inline CSSPrimitiveValue::operator TextDirection() const
3178 {
3179     ASSERT(isValueID());
3180
3181     switch (m_value.valueID) {
3182     case CSSValueLtr:
3183         return LTR;
3184     case CSSValueRtl:
3185         return RTL;
3186     default:
3187         break;
3188     }
3189
3190     ASSERT_NOT_REACHED();
3191     return LTR;
3192 }
3193
3194 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(WritingMode e)
3195     : CSSValue(PrimitiveClass)
3196 {
3197     m_primitiveUnitType = CSS_VALUE_ID;
3198     switch (e) {
3199     case TopToBottomWritingMode:
3200         m_value.valueID = CSSValueHorizontalTb;
3201         break;
3202     case RightToLeftWritingMode:
3203         m_value.valueID = CSSValueVerticalRl;
3204         break;
3205     case LeftToRightWritingMode:
3206         m_value.valueID = CSSValueVerticalLr;
3207         break;
3208     case BottomToTopWritingMode:
3209         m_value.valueID = CSSValueHorizontalBt;
3210         break;
3211     }
3212 }
3213
3214 template<> inline CSSPrimitiveValue::operator WritingMode() const
3215 {
3216     ASSERT(isValueID());
3217
3218     switch (m_value.valueID) {
3219     case CSSValueHorizontalTb:
3220         return TopToBottomWritingMode;
3221     case CSSValueVerticalRl:
3222         return RightToLeftWritingMode;
3223     case CSSValueVerticalLr:
3224         return LeftToRightWritingMode;
3225     case CSSValueHorizontalBt:
3226         return BottomToTopWritingMode;
3227     default:
3228         break;
3229     }
3230
3231     ASSERT_NOT_REACHED();
3232     return TopToBottomWritingMode;
3233 }
3234
3235 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextCombine e)
3236     : CSSValue(PrimitiveClass)
3237 {
3238     m_primitiveUnitType = CSS_VALUE_ID;
3239     switch (e) {
3240     case TextCombineNone:
3241         m_value.valueID = CSSValueNone;
3242         break;
3243     case TextCombineHorizontal:
3244         m_value.valueID = CSSValueHorizontal;
3245         break;
3246     }
3247 }
3248
3249 template<> inline CSSPrimitiveValue::operator TextCombine() const
3250 {
3251     ASSERT(isValueID());
3252
3253     switch (m_value.valueID) {
3254     case CSSValueNone:
3255         return TextCombineNone;
3256     case CSSValueHorizontal:
3257         return TextCombineHorizontal;
3258     default:
3259         break;
3260     }
3261
3262     ASSERT_NOT_REACHED();
3263     return TextCombineNone;
3264 }
3265
3266 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(RubyPosition position)
3267     : CSSValue(PrimitiveClass)
3268 {
3269     m_primitiveUnitType = CSS_VALUE_ID;
3270     switch (position) {
3271     case RubyPositionBefore:
3272         m_value.valueID = CSSValueBefore;
3273         break;
3274     case RubyPositionAfter:
3275         m_value.valueID = CSSValueAfter;
3276         break;
3277     case RubyPositionInterCharacter:
3278         m_value.valueID = CSSValueInterCharacter;
3279         break;
3280     }
3281 }
3282
3283 template<> inline CSSPrimitiveValue::operator RubyPosition() const
3284 {
3285     ASSERT(isValueID());
3286
3287     switch (m_value.valueID) {
3288     case CSSValueBefore:
3289         return RubyPositionBefore;
3290     case CSSValueAfter:
3291         return RubyPositionAfter;
3292     case CSSValueInterCharacter:
3293         return RubyPositionInterCharacter;
3294     default:
3295         break;
3296     }
3297
3298     ASSERT_NOT_REACHED();
3299     return RubyPositionBefore;
3300 }
3301
3302 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextOverflow overflow)
3303     : CSSValue(PrimitiveClass)
3304 {
3305     m_primitiveUnitType = CSS_VALUE_ID;
3306     switch (overflow) {
3307     case TextOverflowClip:
3308         m_value.valueID = CSSValueClip;
3309         break;
3310     case TextOverflowEllipsis:
3311         m_value.valueID = CSSValueEllipsis;
3312         break;
3313     }
3314 }
3315
3316 template<> inline CSSPrimitiveValue::operator TextOverflow() const
3317 {
3318     ASSERT(isValueID());
3319
3320     switch (m_value.valueID) {
3321     case CSSValueClip:
3322         return TextOverflowClip;
3323     case CSSValueEllipsis:
3324         return TextOverflowEllipsis;
3325     default:
3326         break;
3327     }
3328
3329     ASSERT_NOT_REACHED();
3330     return TextOverflowClip;
3331 }
3332
3333 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextEmphasisFill fill)
3334     : CSSValue(PrimitiveClass)
3335 {
3336     m_primitiveUnitType = CSS_VALUE_ID;
3337     switch (fill) {
3338     case TextEmphasisFillFilled:
3339         m_value.valueID = CSSValueFilled;
3340         break;
3341     case TextEmphasisFillOpen:
3342         m_value.valueID = CSSValueOpen;
3343         break;
3344     }
3345 }
3346
3347 template<> inline CSSPrimitiveValue::operator TextEmphasisFill() const
3348 {
3349     ASSERT(isValueID());
3350
3351     switch (m_value.valueID) {
3352     case CSSValueFilled:
3353         return TextEmphasisFillFilled;
3354     case CSSValueOpen:
3355         return TextEmphasisFillOpen;
3356     default:
3357         break;
3358     }
3359
3360     ASSERT_NOT_REACHED();
3361     return TextEmphasisFillFilled;
3362 }
3363
3364 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextEmphasisMark mark)
3365     : CSSValue(PrimitiveClass)
3366 {
3367     m_primitiveUnitType = CSS_VALUE_ID;
3368     switch (mark) {
3369     case TextEmphasisMarkDot:
3370         m_value.valueID = CSSValueDot;
3371         break;
3372     case TextEmphasisMarkCircle:
3373         m_value.valueID = CSSValueCircle;
3374         break;
3375     case TextEmphasisMarkDoubleCircle:
3376         m_value.valueID = CSSValueDoubleCircle;
3377         break;
3378     case TextEmphasisMarkTriangle:
3379         m_value.valueID = CSSValueTriangle;
3380         break;
3381     case TextEmphasisMarkSesame:
3382         m_value.valueID = CSSValueSesame;
3383         break;
3384     case TextEmphasisMarkNone:
3385     case TextEmphasisMarkAuto:
3386     case TextEmphasisMarkCustom:
3387         ASSERT_NOT_REACHED();
3388         m_value.valueID = CSSValueNone;
3389         break;
3390     }
3391 }
3392
3393 template<> inline CSSPrimitiveValue::operator TextEmphasisMark() const
3394 {
3395     ASSERT(isValueID());
3396
3397     switch (m_value.valueID) {
3398     case CSSValueNone:
3399         return TextEmphasisMarkNone;
3400     case CSSValueDot:
3401         return TextEmphasisMarkDot;
3402     case CSSValueCircle:
3403         return TextEmphasisMarkCircle;
3404     case CSSValueDoubleCircle:
3405         return TextEmphasisMarkDoubleCircle;
3406     case CSSValueTriangle:
3407         return TextEmphasisMarkTriangle;
3408     case CSSValueSesame:
3409         return TextEmphasisMarkSesame;
3410     default:
3411         break;
3412     }
3413
3414     ASSERT_NOT_REACHED();
3415     return TextEmphasisMarkNone;
3416 }
3417
3418 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextOrientation e)
3419     : CSSValue(PrimitiveClass)
3420 {
3421     m_primitiveUnitType = CSS_VALUE_ID;
3422     switch (e) {
3423     case TextOrientation::Sideways:
3424         m_value.valueID = CSSValueSideways;
3425         break;
3426     case TextOrientation::Mixed:
3427         m_value.valueID = CSSValueMixed;
3428         break;
3429     case TextOrientation::Upright:
3430         m_value.valueID = CSSValueUpright;
3431         break;
3432     }
3433 }
3434
3435 template<> inline CSSPrimitiveValue::operator TextOrientation() const
3436 {
3437     ASSERT(isValueID());
3438
3439     switch (m_value.valueID) {
3440     case CSSValueSideways:
3441         return TextOrientation::Sideways;
3442     case CSSValueSidewaysRight:
3443         return TextOrientation::Sideways;
3444     case CSSValueVerticalRight:
3445         return TextOrientation::Mixed;
3446     case CSSValueMixed:
3447         return TextOrientation::Mixed;
3448     case CSSValueUpright:
3449         return TextOrientation::Upright;
3450     default:
3451         break;
3452     }
3453
3454     ASSERT_NOT_REACHED();
3455     return TextOrientation::Mixed;
3456 }
3457
3458 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EPointerEvents e)
3459     : CSSValue(PrimitiveClass)
3460 {
3461     m_primitiveUnitType = CSS_VALUE_ID;
3462     switch (e) {
3463     case PE_NONE:
3464         m_value.valueID = CSSValueNone;
3465         break;
3466     case PE_STROKE:
3467         m_value.valueID = CSSValueStroke;
3468         break;
3469     case PE_FILL:
3470         m_value.valueID = CSSValueFill;
3471         break;
3472     case PE_PAINTED:
3473         m_value.valueID = CSSValuePainted;
3474         break;
3475     case PE_VISIBLE:
3476         m_value.valueID = CSSValueVisible;
3477         break;
3478     case PE_VISIBLE_STROKE:
3479         m_value.valueID = CSSValueVisiblestroke;
3480         break;
3481     case PE_VISIBLE_FILL:
3482         m_value.valueID = CSSValueVisiblefill;
3483         break;
3484     case PE_VISIBLE_PAINTED:
3485         m_value.valueID = CSSValueVisiblepainted;
3486         break;
3487     case PE_AUTO:
3488         m_value.valueID = CSSValueAuto;
3489         break;
3490     case PE_ALL:
3491         m_value.valueID = CSSValueAll;
3492         break;
3493     }
3494 }
3495
3496 template<> inline CSSPrimitiveValue::operator EPointerEvents() const
3497 {
3498     ASSERT(isValueID());
3499
3500     switch (m_value.valueID) {
3501     case CSSValueAll:
3502         return PE_ALL;
3503     case CSSValueAuto:
3504         return PE_AUTO;
3505     case CSSValueNone:
3506         return PE_NONE;
3507     case CSSValueVisiblepainted:
3508         return PE_VISIBLE_PAINTED;
3509     case CSSValueVisiblefill:
3510         return PE_VISIBLE_FILL;
3511     case CSSValueVisiblestroke:
3512         return PE_VISIBLE_STROKE;
3513     case CSSValueVisible:
3514         return PE_VISIBLE;
3515     case CSSValuePainted:
3516         return PE_PAINTED;
3517     case CSSValueFill:
3518         return PE_FILL;
3519     case CSSValueStroke:
3520         return PE_STROKE;
3521     default:
3522         break;
3523     }
3524
3525     ASSERT_NOT_REACHED();
3526     return PE_ALL;
3527 }
3528
3529 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(Kerning kerning)
3530     : CSSValue(PrimitiveClass)
3531 {
3532     m_primitiveUnitType = CSS_VALUE_ID;
3533     switch (kerning) {
3534     case Kerning::Auto:
3535         m_value.valueID = CSSValueAuto;
3536         return;
3537     case Kerning::Normal:
3538         m_value.valueID = CSSValueNormal;
3539         return;
3540     case Kerning::NoShift:
3541         m_value.valueID = CSSValueNone;
3542         return;
3543     }
3544
3545     ASSERT_NOT_REACHED();
3546     m_value.valueID = CSSValueAuto;
3547 }
3548
3549 template<> inline CSSPrimitiveValue::operator Kerning() const
3550 {
3551     ASSERT(isValueID());
3552
3553     switch (m_value.valueID) {
3554     case CSSValueAuto:
3555         return Kerning::Auto;
3556     case CSSValueNormal:
3557         return Kerning::Normal;
3558     case CSSValueNone:
3559         return Kerning::NoShift;
3560     default:
3561         break;
3562     }
3563
3564     ASSERT_NOT_REACHED();
3565     return Kerning::Auto;
3566 }
3567
3568 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ObjectFit fit)
3569     : CSSValue(PrimitiveClass)
3570 {
3571     m_primitiveUnitType = CSS_VALUE_ID;
3572     switch (fit) {
3573     case ObjectFitFill:
3574         m_value.valueID = CSSValueFill;
3575         break;
3576     case ObjectFitContain:
3577         m_value.valueID = CSSValueContain;
3578         break;
3579     case ObjectFitCover:
3580         m_value.valueID = CSSValueCover;
3581         break;
3582     case ObjectFitNone:
3583         m_value.valueID = CSSValueNone;
3584         break;
3585     case ObjectFitScaleDown:
3586         m_value.valueID = CSSValueScaleDown;
3587         break;
3588     }
3589 }
3590
3591 template<> inline CSSPrimitiveValue::operator ObjectFit() const
3592 {
3593     ASSERT(isValueID());
3594
3595     switch (m_value.valueID) {
3596     case CSSValueFill:
3597         return ObjectFitFill;
3598     case CSSValueContain:
3599         return ObjectFitContain;
3600     case CSSValueCover:
3601         return ObjectFitCover;
3602     case CSSValueNone:
3603         return ObjectFitNone;
3604     case CSSValueScaleDown:
3605         return ObjectFitScaleDown;
3606     default:
3607         ASSERT_NOT_REACHED();
3608         return ObjectFitFill;
3609     }
3610 }
3611
3612 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontSmoothingMode smoothing)
3613     : CSSValue(PrimitiveClass)
3614 {
3615     m_primitiveUnitType = CSS_VALUE_ID;
3616     switch (smoothing) {
3617     case AutoSmoothing:
3618         m_value.valueID = CSSValueAuto;
3619         return;
3620     case NoSmoothing:
3621         m_value.valueID = CSSValueNone;
3622         return;
3623     case Antialiased:
3624         m_value.valueID = CSSValueAntialiased;
3625         return;
3626     case SubpixelAntialiased:
3627         m_value.valueID = CSSValueSubpixelAntialiased;
3628         return;
3629     }
3630
3631     ASSERT_NOT_REACHED();
3632     m_value.valueID = CSSValueAuto;
3633 }
3634
3635 template<> inline CSSPrimitiveValue::operator FontSmoothingMode() const
3636 {
3637     ASSERT(isValueID());
3638
3639     switch (m_value.valueID) {
3640     case CSSValueAuto:
3641         return AutoSmoothing;
3642     case CSSValueNone:
3643         return NoSmoothing;
3644     case CSSValueAntialiased:
3645         return Antialiased;
3646     case CSSValueSubpixelAntialiased:
3647         return SubpixelAntialiased;
3648     default:
3649         break;
3650     }
3651
3652     ASSERT_NOT_REACHED();
3653     return AutoSmoothing;
3654 }
3655
3656 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontWeight weight)
3657     : CSSValue(PrimitiveClass)
3658 {
3659     m_primitiveUnitType = CSS_VALUE_ID;
3660     switch (weight) {
3661     case FontWeight900:
3662         m_value.valueID = CSSValue900;
3663         return;
3664     case FontWeight800:
3665         m_value.valueID = CSSValue800;
3666         return;
3667     case FontWeight700:
3668         m_value.valueID = CSSValue700;
3669         return;
3670     case FontWeight600:
3671         m_value.valueID = CSSValue600;
3672         return;
3673     case FontWeight500:
3674         m_value.valueID = CSSValue500;
3675         return;
3676     case FontWeight400:
3677         m_value.valueID = CSSValue400;
3678         return;
3679     case FontWeight300:
3680         m_value.valueID = CSSValue300;
3681         return;
3682     case FontWeight200:
3683         m_value.valueID = CSSValue200;
3684         return;
3685     case FontWeight100:
3686         m_value.valueID = CSSValue100;
3687         return;
3688     }
3689
3690     ASSERT_NOT_REACHED();
3691     m_value.valueID = CSSValueNormal;
3692 }
3693
3694 template<> inline CSSPrimitiveValue::operator FontWeight() const
3695 {
3696     ASSERT(isValueID());
3697
3698     switch (m_value.valueID) {
3699     case CSSValueBold:
3700         return FontWeightBold;
3701     case CSSValueNormal:
3702         return FontWeightNormal;
3703     case CSSValue900:
3704         return FontWeight900;
3705     case CSSValue800:
3706         return FontWeight800;
3707     case CSSValue700:
3708         return FontWeight700;
3709     case CSSValue600:
3710         return FontWeight600;
3711     case CSSValue500:
3712         return FontWeight500;
3713     case CSSValue400:
3714         return FontWeight400;
3715     case CSSValue300:
3716         return FontWeight300;
3717     case CSSValue200:
3718         return FontWeight200;
3719     case CSSValue100:
3720         return FontWeight100;
3721     default:
3722         break;
3723     }
3724
3725     ASSERT_NOT_REACHED();
3726     return FontWeightNormal;
3727 }
3728
3729 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontItalic italic)
3730     : CSSValue(PrimitiveClass)
3731 {
3732     m_primitiveUnitType = CSS_VALUE_ID;
3733     switch (italic) {
3734     case FontItalicOff:
3735         m_value.valueID = CSSValueNormal;
3736         return;
3737     case FontItalicOn:
3738         m_value.valueID = CSSValueItalic;
3739         return;
3740     }
3741
3742     ASSERT_NOT_REACHED();
3743     m_value.valueID = CSSValueNormal;
3744 }
3745
3746 template<> inline CSSPrimitiveValue::operator FontItalic() const
3747 {
3748     ASSERT(isValueID());
3749
3750     switch (m_value.valueID) {
3751     case CSSValueOblique:
3752     // FIXME: oblique is the same as italic for the moment...
3753     case CSSValueItalic:
3754         return FontItalicOn;
3755     case CSSValueNormal:
3756         return FontItalicOff;
3757     default:
3758         break;
3759     }
3760     ASSERT_NOT_REACHED();
3761     return FontItalicOff;
3762 }
3763
3764 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontSmallCaps smallCaps)
3765     : CSSValue(PrimitiveClass)
3766 {
3767     m_primitiveUnitType = CSS_VALUE_ID;
3768     switch (smallCaps) {
3769     case FontSmallCapsOff:
3770         m_value.valueID = CSSValueNormal;
3771         return;
3772     case FontSmallCapsOn:
3773         m_value.valueID = CSSValueSmallCaps;
3774         return;
3775     }
3776
3777     ASSERT_NOT_REACHED();
3778     m_value.valueID = CSSValueNormal;
3779 }
3780
3781 template<> inline CSSPrimitiveValue::operator FontSmallCaps() const
3782 {
3783     ASSERT(isValueID());
3784
3785     switch (m_value.valueID) {
3786     case CSSValueSmallCaps:
3787         return FontSmallCapsOn;
3788     case CSSValueNormal:
3789         return FontSmallCapsOff;
3790     default:
3791         break;
3792     }
3793     ASSERT_NOT_REACHED();
3794     return FontSmallCapsOff;
3795 }
3796
3797 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextRenderingMode e)
3798     : CSSValue(PrimitiveClass)
3799 {
3800     m_primitiveUnitType = CSS_VALUE_ID;
3801     switch (e) {
3802     case AutoTextRendering:
3803         m_value.valueID = CSSValueAuto;
3804         break;
3805     case OptimizeSpeed:
3806         m_value.valueID = CSSValueOptimizespeed;
3807         break;
3808     case OptimizeLegibility:
3809         m_value.valueID = CSSValueOptimizelegibility;
3810         break;
3811     case GeometricPrecision:
3812         m_value.valueID = CSSValueGeometricprecision;
3813         break;
3814     }
3815 }
3816
3817 template<> inline CSSPrimitiveValue::operator TextRenderingMode() const
3818 {
3819     ASSERT(isValueID());
3820
3821     switch (m_value.valueID) {
3822     case CSSValueAuto:
3823         return AutoTextRendering;
3824     case CSSValueOptimizespeed:
3825         return OptimizeSpeed;
3826     case CSSValueOptimizelegibility:
3827         return OptimizeLegibility;
3828     case CSSValueGeometricprecision:
3829         return GeometricPrecision;
3830     default:
3831         break;
3832     }
3833
3834     ASSERT_NOT_REACHED();
3835     return AutoTextRendering;
3836 }
3837
3838 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(Hyphens hyphens)
3839     : CSSValue(PrimitiveClass)
3840 {
3841     m_primitiveUnitType = CSS_VALUE_ID;
3842     switch (hyphens) {
3843     case HyphensNone:
3844         m_value.valueID = CSSValueNone;
3845         break;
3846     case HyphensManual:
3847         m_value.valueID = CSSValueManual;
3848         break;
3849     case HyphensAuto:
3850         m_value.valueID = CSSValueAuto;
3851         break;
3852     }
3853 }
3854
3855 template<> inline CSSPrimitiveValue::operator Hyphens() const
3856 {
3857     ASSERT(isValueID());
3858
3859     switch (m_value.valueID) {
3860     case CSSValueNone:
3861         return HyphensNone;
3862     case CSSValueManual:
3863         return HyphensManual;
3864     case CSSValueAuto:
3865         return HyphensAuto;
3866     default:
3867         break;
3868     }
3869
3870     ASSERT_NOT_REACHED();
3871     return HyphensAuto;
3872 }
3873
3874 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineSnap gridSnap)
3875     : CSSValue(PrimitiveClass)
3876 {
3877     m_primitiveUnitType = CSS_VALUE_ID;
3878     switch (gridSnap) {
3879     case LineSnapNone:
3880         m_value.valueID = CSSValueNone;
3881         break;
3882     case LineSnapBaseline:
3883         m_value.valueID = CSSValueBaseline;
3884         break;
3885     case LineSnapContain:
3886         m_value.valueID = CSSValueContain;
3887         break;
3888     }
3889 }
3890
3891 template<> inline CSSPrimitiveValue::operator LineSnap() const
3892 {
3893     ASSERT(isValueID());
3894
3895     switch (m_value.valueID) {
3896     case CSSValueNone:
3897         return LineSnapNone;
3898     case CSSValueBaseline:
3899         return LineSnapBaseline;
3900     case CSSValueContain:
3901         return LineSnapContain;
3902     default:
3903         break;
3904     }
3905
3906     ASSERT_NOT_REACHED();
3907     return LineSnapNone;
3908 }
3909
3910 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineAlign lineAlign)
3911     : CSSValue(PrimitiveClass)
3912 {
3913     m_primitiveUnitType = CSS_VALUE_ID;
3914     switch (lineAlign) {
3915     case LineAlignNone:
3916         m_value.valueID = CSSValueNone;
3917         break;
3918     case LineAlignEdges:
3919         m_value.valueID = CSSValueEdges;
3920         break;
3921     }
3922 }
3923
3924 template<> inline CSSPrimitiveValue::operator LineAlign() const
3925 {
3926     ASSERT(isValueID());
3927
3928     switch (m_value.valueID) {
3929     case CSSValueNone:
3930         return LineAlignNone;
3931     case CSSValueEdges:
3932         return LineAlignEdges;
3933     default:
3934         break;
3935     }
3936
3937     ASSERT_NOT_REACHED();
3938     return LineAlignNone;
3939 }
3940
3941 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ESpeak e)
3942     : CSSValue(PrimitiveClass)
3943 {
3944     m_primitiveUnitType = CSS_VALUE_ID;
3945     switch (e) {
3946     case SpeakNone:
3947         m_value.valueID = CSSValueNone;
3948         break;
3949     case SpeakNormal:
3950         m_value.valueID = CSSValueNormal;
3951         break;
3952     case SpeakSpellOut:
3953         m_value.valueID = CSSValueSpellOut;
3954         break;
3955     case SpeakDigits:
3956         m_value.valueID = CSSValueDigits;
3957         break;
3958     case SpeakLiteralPunctuation:
3959         m_value.valueID = CSSValueLiteralPunctuation;
3960         break;
3961     case SpeakNoPunctuation:
3962         m_value.valueID = CSSValueNoPunctuation;
3963         break;
3964     }
3965 }
3966
3967 template<> inline CSSPrimitiveValue::operator Order() const
3968 {
3969     ASSERT(isValueID());
3970
3971     switch (m_value.valueID) {
3972     case CSSValueLogical:
3973         return LogicalOrder;
3974     case CSSValueVisual:
3975         return VisualOrder;
3976     default:
3977         break;
3978     }
3979
3980     ASSERT_NOT_REACHED();
3981     return LogicalOrder;
3982 }
3983
3984 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(Order e)
3985     : CSSValue(PrimitiveClass)
3986 {
3987     m_primitiveUnitType = CSS_VALUE_ID;
3988     switch (e) {
3989     case LogicalOrder:
3990         m_value.valueID = CSSValueLogical;
3991         break;
3992     case VisualOrder:
3993         m_value.valueID = CSSValueVisual;
3994         break;
3995     }
3996 }
3997
3998 template<> inline CSSPrimitiveValue::operator ESpeak() const
3999 {
4000     ASSERT(isValueID());
4001
4002     switch (m_value.valueID) {
4003     case CSSValueNone:
4004         return SpeakNone;
4005     case CSSValueNormal:
4006         return SpeakNormal;
4007     case CSSValueSpellOut:
4008         return SpeakSpellOut;
4009     case CSSValueDigits:
4010         return SpeakDigits;
4011     case CSSValueLiteralPunctuation:
4012         return SpeakLiteralPunctuation;
4013     case CSSValueNoPunctuation:
4014         return SpeakNoPunctuation;
4015     default:
4016         break;
4017     }
4018
4019     ASSERT_NOT_REACHED();
4020     return SpeakNormal;
4021 }
4022
4023 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(BlendMode blendMode)
4024     : CSSValue(PrimitiveClass)
4025 {
4026     m_primitiveUnitType = CSS_VALUE_ID;
4027     switch (blendMode) {
4028     case BlendModeNormal:
4029         m_value.valueID = CSSValueNormal;
4030         break;
4031     case BlendModeMultiply:
4032         m_value.valueID = CSSValueMultiply;
4033         break;
4034     case BlendModeScreen:
4035         m_value.valueID = CSSValueScreen;
4036         break;
4037     case BlendModeOverlay:
4038         m_value.valueID = CSSValueOverlay;
4039         break;
4040     case BlendModeDarken:
4041         m_value.valueID = CSSValueDarken;
4042         break;
4043     case BlendModeLighten:
4044         m_value.valueID = CSSValueLighten;
4045         break;
4046     case BlendModeColorDodge:
4047         m_value.valueID = CSSValueColorDodge;
4048         break;
4049     case BlendModeColorBurn:
4050         m_value.valueID = CSSValueColorBurn;
4051         break;
4052     case BlendModeHardLight:
4053         m_value.valueID = CSSValueHardLight;
4054         break;
4055     case BlendModeSoftLight:
4056         m_value.valueID = CSSValueSoftLight;
4057         break;
4058     case BlendModeDifference:
4059         m_value.valueID = CSSValueDifference;
4060         break;
4061     case BlendModeExclusion:
4062         m_value.valueID = CSSValueExclusion;
4063         break;
4064     case BlendModeHue:
4065         m_value.valueID = CSSValueHue;
4066         break;
4067     case BlendModeSaturation:
4068         m_value.valueID = CSSValueSaturation;
4069         break;
4070     case BlendModeColor:
4071         m_value.valueID = CSSValueColor;
4072         break;
4073     case BlendModeLuminosity:
4074         m_value.valueID = CSSValueLuminosity;
4075         break;
4076     case BlendModePlusDarker:
4077         m_value.valueID = CSSValuePlusDarker;
4078         break;
4079     case BlendModePlusLighter:
4080         m_value.valueID = CSSValuePlusLighter;
4081         break;
4082     }
4083 }
4084
4085 template<> inline CSSPrimitiveValue::operator BlendMode() const
4086 {
4087     ASSERT(isValueID());
4088
4089     switch (m_value.valueID) {
4090     case CSSValueNormal:
4091         return BlendModeNormal;
4092     case CSSValueMultiply:
4093         return BlendModeMultiply;
4094     case CSSValueScreen:
4095         return BlendModeScreen;
4096     case CSSValueOverlay:
4097         return BlendModeOverlay;
4098     case CSSValueDarken:
4099         return BlendModeDarken;
4100     case CSSValueLighten:
4101         return BlendModeLighten;
4102     case CSSValueColorDodge:
4103         return BlendModeColorDodge;
4104     case CSSValueColorBurn:
4105         return BlendModeColorBurn;
4106     case CSSValueHardLight:
4107         return BlendModeHardLight;
4108     case CSSValueSoftLight:
4109         return BlendModeSoftLight;
4110     case CSSValueDifference:
4111         return BlendModeDifference;
4112     case CSSValueExclusion:
4113         return BlendModeExclusion;
4114     case CSSValueHue:
4115         return BlendModeHue;
4116     case CSSValueSaturation:
4117         return BlendModeSaturation;
4118     case CSSValueColor:
4119         return BlendModeColor;
4120     case CSSValueLuminosity:
4121         return BlendModeLuminosity;
4122     case CSSValuePlusDarker:
4123         return BlendModePlusDarker;
4124     case CSSValuePlusLighter:
4125         return BlendModePlusLighter;
4126     default:
4127         break;
4128     }
4129
4130     ASSERT_NOT_REACHED();
4131     return BlendModeNormal;
4132 }
4133
4134 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(Isolation isolation)
4135     : CSSValue(PrimitiveClass)
4136 {
4137     m_primitiveUnitType = CSS_VALUE_ID;
4138     switch (isolation) {
4139     case IsolationAuto:
4140         m_value.valueID = CSSValueAuto;
4141         break;
4142     case IsolationIsolate:
4143         m_value.valueID = CSSValueIsolate;
4144         break;
4145     default:
4146         ASSERT_NOT_REACHED();
4147     }
4148 }
4149
4150 template<> inline CSSPrimitiveValue::operator Isolation() const
4151 {
4152     ASSERT(isValueID());
4153     switch (m_value.valueID) {
4154     case CSSValueAuto:
4155         return IsolationAuto;
4156     case CSSValueIsolate:
4157         return IsolationIsolate;
4158     default:
4159         break;
4160     }
4161
4162     ASSERT_NOT_REACHED();
4163     return IsolationAuto;
4164 }
4165
4166 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineCap e)
4167     : CSSValue(PrimitiveClass)
4168 {
4169     m_primitiveUnitType = CSS_VALUE_ID;
4170     switch (e) {
4171     case ButtCap:
4172         m_value.valueID = CSSValueButt;
4173         break;
4174     case RoundCap:
4175         m_value.valueID = CSSValueRound;
4176         break;
4177     case SquareCap:
4178         m_value.valueID = CSSValueSquare;
4179         break;
4180     }
4181 }
4182
4183 template<> inline CSSPrimitiveValue::operator LineCap() const
4184 {
4185     ASSERT(isValueID());
4186
4187     switch (m_value.valueID) {
4188     case CSSValueButt:
4189         return ButtCap;
4190     case CSSValueRound:
4191         return RoundCap;
4192     case CSSValueSquare:
4193         return SquareCap;
4194     default:
4195         break;
4196     }
4197
4198     ASSERT_NOT_REACHED();
4199     return ButtCap;
4200 }
4201
4202 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineJoin e)
4203     : CSSValue(PrimitiveClass)
4204 {
4205     m_primitiveUnitType = CSS_VALUE_ID;
4206     switch (e) {
4207     case MiterJoin:
4208         m_value.valueID = CSSValueMiter;
4209         break;
4210     case RoundJoin:
4211         m_value.valueID = CSSValueRound;
4212         break;
4213     case BevelJoin:
4214         m_value.valueID = CSSValueBevel;
4215         break;
4216     }
4217 }
4218
4219 template<> inline CSSPrimitiveValue::operator LineJoin() const
4220 {
4221     ASSERT(isValueID());
4222
4223     switch (m_value.valueID) {
4224     case CSSValueMiter:
4225         return MiterJoin;
4226     case CSSValueRound:
4227         return RoundJoin;
4228     case CSSValueBevel:
4229         return BevelJoin;
4230     default: