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