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