1/*
2 * Copyright (C) 2007 Alexey Proskuryakov <ap@nypop.com>.
3 * Copyright (C) 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
4 * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
5 * Copyright (C) 2009 Jeff Schiller <codedread@gmail.com>
6 * Copyright (C) Research In Motion Limited 2010. All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 *
12 * 1. Redistributions of source code must retain the above copyright
13 *    notice, this list of conditions and the following disclaimer.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 *    notice, this list of conditions and the following disclaimer in the
16 *    documentation and/or other materials provided with the distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
19 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
23 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 */
29
30#ifndef CSSPrimitiveValueMappings_h
31#define CSSPrimitiveValueMappings_h
32
33#include "CSSCalculationValue.h"
34#include "CSSPrimitiveValue.h"
35#include "CSSReflectionDirection.h"
36#include "CSSToLengthConversionData.h"
37#include "ColorSpace.h"
38#include "CSSValueKeywords.h"
39#include "FontDescription.h"
40#include "FontSmoothingMode.h"
41#include "GraphicsTypes.h"
42#include "Length.h"
43#include "LineClampValue.h"
44#include "Path.h"
45#include "RenderStyleConstants.h"
46#include "SVGRenderStyleDefs.h"
47#include "TextDirection.h"
48#include "TextRenderingMode.h"
49#include "ThemeTypes.h"
50#include "UnicodeBidi.h"
51#include "WritingMode.h"
52#include <wtf/MathExtras.h>
53
54#if ENABLE(CSS_IMAGE_ORIENTATION)
55#include "ImageOrientation.h"
56#endif
57
58namespace WebCore {
59
60template<> inline CSSPrimitiveValue::CSSPrimitiveValue(short i)
61    : CSSValue(PrimitiveClass)
62{
63    m_primitiveUnitType = CSS_NUMBER;
64    m_value.num = static_cast<double>(i);
65}
66
67template<> inline CSSPrimitiveValue::operator short() const
68{
69    if (m_primitiveUnitType == CSS_NUMBER)
70        return clampTo<short>(m_value.num);
71
72    ASSERT_NOT_REACHED();
73    return 0;
74}
75
76template<> inline CSSPrimitiveValue::CSSPrimitiveValue(unsigned short i)
77    : CSSValue(PrimitiveClass)
78{
79    m_primitiveUnitType = CSS_NUMBER;
80    m_value.num = static_cast<double>(i);
81}
82
83template<> inline CSSPrimitiveValue::operator unsigned short() const
84{
85    if (m_primitiveUnitType == CSS_NUMBER)
86        return clampTo<unsigned short>(m_value.num);
87
88    ASSERT_NOT_REACHED();
89    return 0;
90}
91
92template<> inline CSSPrimitiveValue::operator int() const
93{
94    if (m_primitiveUnitType == CSS_NUMBER)
95        return clampTo<int>(m_value.num);
96
97    ASSERT_NOT_REACHED();
98    return 0;
99}
100
101template<> inline CSSPrimitiveValue::operator unsigned() const
102{
103    if (m_primitiveUnitType == CSS_NUMBER)
104        return clampTo<unsigned>(m_value.num);
105
106    ASSERT_NOT_REACHED();
107    return 0;
108}
109
110
111template<> inline CSSPrimitiveValue::CSSPrimitiveValue(float i)
112    : CSSValue(PrimitiveClass)
113{
114    m_primitiveUnitType = CSS_NUMBER;
115    m_value.num = static_cast<double>(i);
116}
117
118template<> inline CSSPrimitiveValue::operator float() const
119{
120    if (m_primitiveUnitType == CSS_NUMBER)
121        return clampTo<float>(m_value.num);
122
123    ASSERT_NOT_REACHED();
124    return 0.0f;
125}
126
127template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineClampValue i)
128    : CSSValue(PrimitiveClass)
129{
130    m_primitiveUnitType = i.isPercentage() ? CSS_PERCENTAGE : CSS_NUMBER;
131    m_value.num = static_cast<double>(i.value());
132}
133
134template<> inline CSSPrimitiveValue::operator LineClampValue() const
135{
136    if (m_primitiveUnitType == CSS_NUMBER)
137        return LineClampValue(clampTo<int>(m_value.num), LineClampLineCount);
138
139    if (m_primitiveUnitType == CSS_PERCENTAGE)
140        return LineClampValue(clampTo<int>(m_value.num), LineClampPercentage);
141
142    ASSERT_NOT_REACHED();
143    return LineClampValue();
144}
145
146template<> inline CSSPrimitiveValue::CSSPrimitiveValue(CSSReflectionDirection e)
147    : CSSValue(PrimitiveClass)
148{
149    m_primitiveUnitType = CSS_VALUE_ID;
150    switch (e) {
151    case ReflectionAbove:
152        m_value.valueID = CSSValueAbove;
153        break;
154    case ReflectionBelow:
155        m_value.valueID = CSSValueBelow;
156        break;
157    case ReflectionLeft:
158        m_value.valueID = CSSValueLeft;
159        break;
160    case ReflectionRight:
161        m_value.valueID = CSSValueRight;
162    }
163}
164
165template<> inline CSSPrimitiveValue::operator CSSReflectionDirection() const
166{
167    ASSERT(isValueID());
168
169    switch (m_value.valueID) {
170    case CSSValueAbove:
171        return ReflectionAbove;
172    case CSSValueBelow:
173        return ReflectionBelow;
174    case CSSValueLeft:
175        return ReflectionLeft;
176    case CSSValueRight:
177        return ReflectionRight;
178    default:
179        break;
180    }
181
182    ASSERT_NOT_REACHED();
183    return ReflectionBelow;
184}
185
186template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ColumnFill columnFill)
187    : CSSValue(PrimitiveClass)
188{
189    m_primitiveUnitType = CSS_VALUE_ID;
190    switch (columnFill) {
191    case ColumnFillAuto:
192        m_value.valueID = CSSValueAuto;
193        break;
194    case ColumnFillBalance:
195        m_value.valueID = CSSValueBalance;
196        break;
197    }
198}
199
200template<> inline CSSPrimitiveValue::operator ColumnFill() const
201{
202    if (m_primitiveUnitType == CSS_VALUE_ID) {
203        if (m_value.valueID == CSSValueBalance)
204            return ColumnFillBalance;
205        if (m_value.valueID == CSSValueAuto)
206            return ColumnFillAuto;
207    }
208    ASSERT_NOT_REACHED();
209    return ColumnFillBalance;
210}
211
212template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ColumnSpan columnSpan)
213    : CSSValue(PrimitiveClass)
214{
215    m_primitiveUnitType = CSS_VALUE_ID;
216    switch (columnSpan) {
217    case ColumnSpanAll:
218        m_value.valueID = CSSValueAll;
219        break;
220    case ColumnSpanNone:
221        m_value.valueID = CSSValueNone;
222        break;
223    }
224}
225
226template<> inline CSSPrimitiveValue::operator ColumnSpan() const
227{
228    // Map 1 to none for compatibility reasons.
229    if (m_primitiveUnitType == CSS_NUMBER && m_value.num == 1)
230        return ColumnSpanNone;
231
232    ASSERT(isValueID());
233
234    switch (m_value.valueID) {
235    case CSSValueAll:
236        return ColumnSpanAll;
237    case CSSValueNone:
238        return ColumnSpanNone;
239    default:
240        break;
241    }
242
243    ASSERT_NOT_REACHED();
244    return ColumnSpanNone;
245}
246
247
248template<> inline CSSPrimitiveValue::CSSPrimitiveValue(PrintColorAdjust value)
249    : CSSValue(PrimitiveClass)
250{
251    m_primitiveUnitType = CSS_VALUE_ID;
252    switch (value) {
253    case PrintColorAdjustExact:
254        m_value.valueID = CSSValueExact;
255        break;
256    case PrintColorAdjustEconomy:
257        m_value.valueID = CSSValueEconomy;
258        break;
259    }
260}
261
262template<> inline CSSPrimitiveValue::operator PrintColorAdjust() const
263{
264    ASSERT(isValueID());
265
266    switch (m_value.valueID) {
267    case CSSValueEconomy:
268        return PrintColorAdjustEconomy;
269    case CSSValueExact:
270        return PrintColorAdjustExact;
271    default:
272        break;
273    }
274
275    ASSERT_NOT_REACHED();
276    return PrintColorAdjustEconomy;
277}
278
279
280template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBorderStyle e)
281    : CSSValue(PrimitiveClass)
282{
283    m_primitiveUnitType = CSS_VALUE_ID;
284    switch (e) {
285    case BNONE:
286        m_value.valueID = CSSValueNone;
287        break;
288    case BHIDDEN:
289        m_value.valueID = CSSValueHidden;
290        break;
291    case INSET:
292        m_value.valueID = CSSValueInset;
293        break;
294    case GROOVE:
295        m_value.valueID = CSSValueGroove;
296        break;
297    case RIDGE:
298        m_value.valueID = CSSValueRidge;
299        break;
300    case OUTSET:
301        m_value.valueID = CSSValueOutset;
302        break;
303    case DOTTED:
304        m_value.valueID = CSSValueDotted;
305        break;
306    case DASHED:
307        m_value.valueID = CSSValueDashed;
308        break;
309    case SOLID:
310        m_value.valueID = CSSValueSolid;
311        break;
312    case DOUBLE:
313        m_value.valueID = CSSValueDouble;
314        break;
315    }
316}
317
318template<> inline CSSPrimitiveValue::operator EBorderStyle() const
319{
320    ASSERT(isValueID());
321
322    if (m_value.valueID == CSSValueAuto) // Valid for CSS outline-style
323        return DOTTED;
324    return (EBorderStyle)(m_value.valueID - CSSValueNone);
325}
326
327template<> inline CSSPrimitiveValue::operator OutlineIsAuto() const
328{
329    ASSERT(isValueID());
330
331    if (m_value.valueID == CSSValueAuto)
332        return AUTO_ON;
333    return AUTO_OFF;
334}
335
336template<> inline CSSPrimitiveValue::CSSPrimitiveValue(CompositeOperator e)
337    : CSSValue(PrimitiveClass)
338{
339    m_primitiveUnitType = CSS_VALUE_ID;
340    switch (e) {
341    case CompositeClear:
342        m_value.valueID = CSSValueClear;
343        break;
344    case CompositeCopy:
345        m_value.valueID = CSSValueCopy;
346        break;
347    case CompositeSourceOver:
348        m_value.valueID = CSSValueSourceOver;
349        break;
350    case CompositeSourceIn:
351        m_value.valueID = CSSValueSourceIn;
352        break;
353    case CompositeSourceOut:
354        m_value.valueID = CSSValueSourceOut;
355        break;
356    case CompositeSourceAtop:
357        m_value.valueID = CSSValueSourceAtop;
358        break;
359    case CompositeDestinationOver:
360        m_value.valueID = CSSValueDestinationOver;
361        break;
362    case CompositeDestinationIn:
363        m_value.valueID = CSSValueDestinationIn;
364        break;
365    case CompositeDestinationOut:
366        m_value.valueID = CSSValueDestinationOut;
367        break;
368    case CompositeDestinationAtop:
369        m_value.valueID = CSSValueDestinationAtop;
370        break;
371    case CompositeXOR:
372        m_value.valueID = CSSValueXor;
373        break;
374    case CompositePlusDarker:
375        m_value.valueID = CSSValuePlusDarker;
376        break;
377    case CompositePlusLighter:
378        m_value.valueID = CSSValuePlusLighter;
379        break;
380    case CompositeDifference:
381        ASSERT_NOT_REACHED();
382        break;
383    }
384}
385
386template<> inline CSSPrimitiveValue::operator CompositeOperator() const
387{
388    ASSERT(isValueID());
389
390    switch (m_value.valueID) {
391    case CSSValueClear:
392        return CompositeClear;
393    case CSSValueCopy:
394        return CompositeCopy;
395    case CSSValueSourceOver:
396        return CompositeSourceOver;
397    case CSSValueSourceIn:
398        return CompositeSourceIn;
399    case CSSValueSourceOut:
400        return CompositeSourceOut;
401    case CSSValueSourceAtop:
402        return CompositeSourceAtop;
403    case CSSValueDestinationOver:
404        return CompositeDestinationOver;
405    case CSSValueDestinationIn:
406        return CompositeDestinationIn;
407    case CSSValueDestinationOut:
408        return CompositeDestinationOut;
409    case CSSValueDestinationAtop:
410        return CompositeDestinationAtop;
411    case CSSValueXor:
412        return CompositeXOR;
413    case CSSValuePlusDarker:
414        return CompositePlusDarker;
415    case CSSValuePlusLighter:
416        return CompositePlusLighter;
417    default:
418        break;
419    }
420
421    ASSERT_NOT_REACHED();
422    return CompositeClear;
423}
424
425template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ControlPart e)
426    : CSSValue(PrimitiveClass)
427{
428    m_primitiveUnitType = CSS_VALUE_ID;
429    switch (e) {
430    case NoControlPart:
431        m_value.valueID = CSSValueNone;
432        break;
433    case CheckboxPart:
434        m_value.valueID = CSSValueCheckbox;
435        break;
436    case RadioPart:
437        m_value.valueID = CSSValueRadio;
438        break;
439    case PushButtonPart:
440        m_value.valueID = CSSValuePushButton;
441        break;
442    case SquareButtonPart:
443        m_value.valueID = CSSValueSquareButton;
444        break;
445    case ButtonPart:
446        m_value.valueID = CSSValueButton;
447        break;
448    case ButtonBevelPart:
449        m_value.valueID = CSSValueButtonBevel;
450        break;
451    case DefaultButtonPart:
452        m_value.valueID = CSSValueDefaultButton;
453        break;
454    case InnerSpinButtonPart:
455        m_value.valueID = CSSValueInnerSpinButton;
456        break;
457    case ListboxPart:
458        m_value.valueID = CSSValueListbox;
459        break;
460    case ListItemPart:
461        m_value.valueID = CSSValueListitem;
462        break;
463    case MediaEnterFullscreenButtonPart:
464        m_value.valueID = CSSValueMediaEnterFullscreenButton;
465        break;
466    case MediaExitFullscreenButtonPart:
467        m_value.valueID = CSSValueMediaExitFullscreenButton;
468        break;
469    case MediaPlayButtonPart:
470        m_value.valueID = CSSValueMediaPlayButton;
471        break;
472    case MediaOverlayPlayButtonPart:
473        m_value.valueID = CSSValueMediaOverlayPlayButton;
474        break;
475    case MediaMuteButtonPart:
476        m_value.valueID = CSSValueMediaMuteButton;
477        break;
478    case MediaSeekBackButtonPart:
479        m_value.valueID = CSSValueMediaSeekBackButton;
480        break;
481    case MediaSeekForwardButtonPart:
482        m_value.valueID = CSSValueMediaSeekForwardButton;
483        break;
484    case MediaRewindButtonPart:
485        m_value.valueID = CSSValueMediaRewindButton;
486        break;
487    case MediaReturnToRealtimeButtonPart:
488        m_value.valueID = CSSValueMediaReturnToRealtimeButton;
489        break;
490    case MediaToggleClosedCaptionsButtonPart:
491        m_value.valueID = CSSValueMediaToggleClosedCaptionsButton;
492        break;
493    case MediaSliderPart:
494        m_value.valueID = CSSValueMediaSlider;
495        break;
496    case MediaSliderThumbPart:
497        m_value.valueID = CSSValueMediaSliderthumb;
498        break;
499    case MediaVolumeSliderContainerPart:
500        m_value.valueID = CSSValueMediaVolumeSliderContainer;
501        break;
502    case MediaVolumeSliderPart:
503        m_value.valueID = CSSValueMediaVolumeSlider;
504        break;
505    case MediaVolumeSliderMuteButtonPart:
506        m_value.valueID = CSSValueMediaVolumeSliderMuteButton;
507        break;
508    case MediaVolumeSliderThumbPart:
509        m_value.valueID = CSSValueMediaVolumeSliderthumb;
510        break;
511    case MediaControlsBackgroundPart:
512        m_value.valueID = CSSValueMediaControlsBackground;
513        break;
514    case MediaControlsFullscreenBackgroundPart:
515        m_value.valueID = CSSValueMediaControlsFullscreenBackground;
516        break;
517    case MediaFullScreenVolumeSliderPart:
518        m_value.valueID = CSSValueMediaFullscreenVolumeSlider;
519        break;
520    case MediaFullScreenVolumeSliderThumbPart:
521        m_value.valueID = CSSValueMediaFullscreenVolumeSliderThumb;
522        break;
523    case MediaCurrentTimePart:
524        m_value.valueID = CSSValueMediaCurrentTimeDisplay;
525        break;
526    case MediaTimeRemainingPart:
527        m_value.valueID = CSSValueMediaTimeRemainingDisplay;
528        break;
529    case MenulistPart:
530        m_value.valueID = CSSValueMenulist;
531        break;
532    case MenulistButtonPart:
533        m_value.valueID = CSSValueMenulistButton;
534        break;
535    case MenulistTextPart:
536        m_value.valueID = CSSValueMenulistText;
537        break;
538    case MenulistTextFieldPart:
539        m_value.valueID = CSSValueMenulistTextfield;
540        break;
541    case MeterPart:
542        m_value.valueID = CSSValueMeter;
543        break;
544    case RelevancyLevelIndicatorPart:
545        m_value.valueID = CSSValueRelevancyLevelIndicator;
546        break;
547    case ContinuousCapacityLevelIndicatorPart:
548        m_value.valueID = CSSValueContinuousCapacityLevelIndicator;
549        break;
550    case DiscreteCapacityLevelIndicatorPart:
551        m_value.valueID = CSSValueDiscreteCapacityLevelIndicator;
552        break;
553    case RatingLevelIndicatorPart:
554        m_value.valueID = CSSValueRatingLevelIndicator;
555        break;
556    case ProgressBarPart:
557        m_value.valueID = CSSValueProgressBar;
558        break;
559    case ProgressBarValuePart:
560        m_value.valueID = CSSValueProgressBarValue;
561        break;
562    case SliderHorizontalPart:
563        m_value.valueID = CSSValueSliderHorizontal;
564        break;
565    case SliderVerticalPart:
566        m_value.valueID = CSSValueSliderVertical;
567        break;
568    case SliderThumbHorizontalPart:
569        m_value.valueID = CSSValueSliderthumbHorizontal;
570        break;
571    case SliderThumbVerticalPart:
572        m_value.valueID = CSSValueSliderthumbVertical;
573        break;
574    case CaretPart:
575        m_value.valueID = CSSValueCaret;
576        break;
577    case SearchFieldPart:
578        m_value.valueID = CSSValueSearchfield;
579        break;
580    case SearchFieldDecorationPart:
581        m_value.valueID = CSSValueSearchfieldDecoration;
582        break;
583    case SearchFieldResultsDecorationPart:
584        m_value.valueID = CSSValueSearchfieldResultsDecoration;
585        break;
586    case SearchFieldResultsButtonPart:
587        m_value.valueID = CSSValueSearchfieldResultsButton;
588        break;
589    case SearchFieldCancelButtonPart:
590        m_value.valueID = CSSValueSearchfieldCancelButton;
591        break;
592    case SnapshottedPluginOverlayPart:
593        m_value.valueID = CSSValueSnapshottedPluginOverlay;
594        break;
595    case TextFieldPart:
596        m_value.valueID = CSSValueTextfield;
597        break;
598    case TextAreaPart:
599        m_value.valueID = CSSValueTextarea;
600        break;
601    case CapsLockIndicatorPart:
602        m_value.valueID = CSSValueCapsLockIndicator;
603        break;
604#if ENABLE(SERVICE_CONTROLS)
605    case ImageControlsButtonPart:
606        m_value.valueID = CSSValueImageControlsButton;
607        break;
608#endif
609    case InputSpeechButtonPart:
610#if ENABLE(INPUT_SPEECH)
611        m_value.valueID = CSSValueWebkitInputSpeechButton;
612#endif
613        break;
614    }
615}
616
617template<> inline CSSPrimitiveValue::operator ControlPart() const
618{
619    ASSERT(isValueID());
620
621    if (m_value.valueID == CSSValueNone)
622        return NoControlPart;
623    return ControlPart(m_value.valueID - CSSValueCheckbox + 1);
624}
625
626template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBackfaceVisibility e)
627    : CSSValue(PrimitiveClass)
628{
629    m_primitiveUnitType = CSS_VALUE_ID;
630    switch (e) {
631    case BackfaceVisibilityVisible:
632        m_value.valueID = CSSValueVisible;
633        break;
634    case BackfaceVisibilityHidden:
635        m_value.valueID = CSSValueHidden;
636        break;
637    }
638}
639
640template<> inline CSSPrimitiveValue::operator EBackfaceVisibility() const
641{
642    ASSERT(isValueID());
643
644    switch (m_value.valueID) {
645    case CSSValueVisible:
646        return BackfaceVisibilityVisible;
647    case CSSValueHidden:
648        return BackfaceVisibilityHidden;
649    default:
650        break;
651    }
652
653    ASSERT_NOT_REACHED();
654    return BackfaceVisibilityHidden;
655}
656
657
658template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFillAttachment e)
659    : CSSValue(PrimitiveClass)
660{
661    m_primitiveUnitType = CSS_VALUE_ID;
662    switch (e) {
663    case ScrollBackgroundAttachment:
664        m_value.valueID = CSSValueScroll;
665        break;
666    case LocalBackgroundAttachment:
667        m_value.valueID = CSSValueLocal;
668        break;
669    case FixedBackgroundAttachment:
670        m_value.valueID = CSSValueFixed;
671        break;
672    }
673}
674
675template<> inline CSSPrimitiveValue::operator EFillAttachment() const
676{
677    ASSERT(isValueID());
678
679    switch (m_value.valueID) {
680    case CSSValueScroll:
681        return ScrollBackgroundAttachment;
682    case CSSValueLocal:
683        return LocalBackgroundAttachment;
684    case CSSValueFixed:
685        return FixedBackgroundAttachment;
686    default:
687        break;
688    }
689
690    ASSERT_NOT_REACHED();
691    return ScrollBackgroundAttachment;
692}
693
694template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFillBox e)
695    : CSSValue(PrimitiveClass)
696{
697    m_primitiveUnitType = CSS_VALUE_ID;
698    switch (e) {
699    case BorderFillBox:
700        m_value.valueID = CSSValueBorderBox;
701        break;
702    case PaddingFillBox:
703        m_value.valueID = CSSValuePaddingBox;
704        break;
705    case ContentFillBox:
706        m_value.valueID = CSSValueContentBox;
707        break;
708    case TextFillBox:
709        m_value.valueID = CSSValueText;
710        break;
711    }
712}
713
714template<> inline CSSPrimitiveValue::operator EFillBox() const
715{
716    ASSERT(isValueID());
717
718    switch (m_value.valueID) {
719    case CSSValueBorder:
720    case CSSValueBorderBox:
721        return BorderFillBox;
722    case CSSValuePadding:
723    case CSSValuePaddingBox:
724        return PaddingFillBox;
725    case CSSValueContent:
726    case CSSValueContentBox:
727        return ContentFillBox;
728    case CSSValueText:
729    case CSSValueWebkitText:
730        return TextFillBox;
731    default:
732        break;
733    }
734
735    ASSERT_NOT_REACHED();
736    return BorderFillBox;
737}
738
739template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFillRepeat e)
740    : CSSValue(PrimitiveClass)
741{
742    m_primitiveUnitType = CSS_VALUE_ID;
743    switch (e) {
744    case RepeatFill:
745        m_value.valueID = CSSValueRepeat;
746        break;
747    case NoRepeatFill:
748        m_value.valueID = CSSValueNoRepeat;
749        break;
750    case RoundFill:
751        m_value.valueID = CSSValueRound;
752        break;
753    case SpaceFill:
754        m_value.valueID = CSSValueSpace;
755        break;
756    }
757}
758
759template<> inline CSSPrimitiveValue::operator EFillRepeat() const
760{
761    ASSERT(isValueID());
762
763    switch (m_value.valueID) {
764    case CSSValueRepeat:
765        return RepeatFill;
766    case CSSValueNoRepeat:
767        return NoRepeatFill;
768    case CSSValueRound:
769        return RoundFill;
770    case CSSValueSpace:
771        return SpaceFill;
772    default:
773        break;
774    }
775
776    ASSERT_NOT_REACHED();
777    return RepeatFill;
778}
779
780template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxPack e)
781    : CSSValue(PrimitiveClass)
782{
783    m_primitiveUnitType = CSS_VALUE_ID;
784    switch (e) {
785    case Start:
786        m_value.valueID = CSSValueStart;
787        break;
788    case Center:
789        m_value.valueID = CSSValueCenter;
790        break;
791    case End:
792        m_value.valueID = CSSValueEnd;
793        break;
794    case Justify:
795        m_value.valueID = CSSValueJustify;
796        break;
797    }
798}
799
800template<> inline CSSPrimitiveValue::operator EBoxPack() const
801{
802    ASSERT(isValueID());
803
804    switch (m_value.valueID) {
805    case CSSValueStart:
806        return Start;
807    case CSSValueEnd:
808        return End;
809    case CSSValueCenter:
810        return Center;
811    case CSSValueJustify:
812        return Justify;
813    default:
814        break;
815    }
816
817    ASSERT_NOT_REACHED();
818    return Justify;
819}
820
821template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxAlignment e)
822    : CSSValue(PrimitiveClass)
823{
824    m_primitiveUnitType = CSS_VALUE_ID;
825    switch (e) {
826    case BSTRETCH:
827        m_value.valueID = CSSValueStretch;
828        break;
829    case BSTART:
830        m_value.valueID = CSSValueStart;
831        break;
832    case BCENTER:
833        m_value.valueID = CSSValueCenter;
834        break;
835    case BEND:
836        m_value.valueID = CSSValueEnd;
837        break;
838    case BBASELINE:
839        m_value.valueID = CSSValueBaseline;
840        break;
841    }
842}
843
844template<> inline CSSPrimitiveValue::operator EBoxAlignment() const
845{
846    ASSERT(isValueID());
847
848    switch (m_value.valueID) {
849    case CSSValueStretch:
850        return BSTRETCH;
851    case CSSValueStart:
852        return BSTART;
853    case CSSValueEnd:
854        return BEND;
855    case CSSValueCenter:
856        return BCENTER;
857    case CSSValueBaseline:
858        return BBASELINE;
859    default:
860        break;
861    }
862
863    ASSERT_NOT_REACHED();
864    return BSTRETCH;
865}
866
867#if ENABLE(CSS_BOX_DECORATION_BREAK)
868template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxDecorationBreak e)
869    : CSSValue(PrimitiveClass)
870{
871    m_primitiveUnitType = CSS_VALUE_ID;
872    switch (e) {
873    case DSLICE:
874        m_value.valueID = CSSValueSlice;
875        break;
876    case DCLONE:
877        m_value.valueID = CSSValueClone;
878        break;
879    }
880}
881
882template<> inline CSSPrimitiveValue::operator EBoxDecorationBreak() const
883{
884    ASSERT(isValueID());
885
886    switch (m_value.valueID) {
887    case CSSValueSlice:
888        return DSLICE;
889    case CSSValueClone:
890        return DCLONE;
891    default:
892        break;
893    }
894
895    ASSERT_NOT_REACHED();
896    return DSLICE;
897}
898#endif
899
900template<> inline CSSPrimitiveValue::CSSPrimitiveValue(BackgroundEdgeOrigin e)
901    : CSSValue(PrimitiveClass)
902{
903    m_primitiveUnitType = CSS_VALUE_ID;
904    switch (e) {
905    case TopEdge:
906        m_value.valueID = CSSValueTop;
907        break;
908    case RightEdge:
909        m_value.valueID = CSSValueRight;
910        break;
911    case BottomEdge:
912        m_value.valueID = CSSValueBottom;
913        break;
914    case LeftEdge:
915        m_value.valueID = CSSValueLeft;
916        break;
917    }
918}
919
920template<> inline CSSPrimitiveValue::operator BackgroundEdgeOrigin() const
921{
922    ASSERT(isValueID());
923
924    switch (m_value.valueID) {
925    case CSSValueTop:
926        return TopEdge;
927    case CSSValueRight:
928        return RightEdge;
929    case CSSValueBottom:
930        return BottomEdge;
931    case CSSValueLeft:
932        return LeftEdge;
933    default:
934        break;
935    }
936
937    ASSERT_NOT_REACHED();
938    return TopEdge;
939}
940
941template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxSizing e)
942    : CSSValue(PrimitiveClass)
943{
944    m_primitiveUnitType = CSS_VALUE_ID;
945    switch (e) {
946    case BORDER_BOX:
947        m_value.valueID = CSSValueBorderBox;
948        break;
949    case CONTENT_BOX:
950        m_value.valueID = CSSValueContentBox;
951        break;
952    }
953}
954
955template<> inline CSSPrimitiveValue::operator EBoxSizing() const
956{
957    ASSERT(isValueID());
958
959    switch (m_value.valueID) {
960    case CSSValueBorderBox:
961        return BORDER_BOX;
962    case CSSValueContentBox:
963        return CONTENT_BOX;
964    default:
965        break;
966    }
967
968    ASSERT_NOT_REACHED();
969    return BORDER_BOX;
970}
971
972template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxDirection e)
973    : CSSValue(PrimitiveClass)
974{
975    m_primitiveUnitType = CSS_VALUE_ID;
976    switch (e) {
977    case BNORMAL:
978        m_value.valueID = CSSValueNormal;
979        break;
980    case BREVERSE:
981        m_value.valueID = CSSValueReverse;
982        break;
983    }
984}
985
986template<> inline CSSPrimitiveValue::operator EBoxDirection() const
987{
988    ASSERT(isValueID());
989
990    switch (m_value.valueID) {
991    case CSSValueNormal:
992        return BNORMAL;
993    case CSSValueReverse:
994        return BREVERSE;
995    default:
996        break;
997    }
998
999    ASSERT_NOT_REACHED();
1000    return BNORMAL;
1001}
1002
1003template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxLines e)
1004    : CSSValue(PrimitiveClass)
1005{
1006    m_primitiveUnitType = CSS_VALUE_ID;
1007    switch (e) {
1008    case SINGLE:
1009        m_value.valueID = CSSValueSingle;
1010        break;
1011    case MULTIPLE:
1012        m_value.valueID = CSSValueMultiple;
1013        break;
1014    }
1015}
1016
1017template<> inline CSSPrimitiveValue::operator EBoxLines() const
1018{
1019    ASSERT(isValueID());
1020
1021    switch (m_value.valueID) {
1022    case CSSValueSingle:
1023        return SINGLE;
1024    case CSSValueMultiple:
1025        return MULTIPLE;
1026    default:
1027        break;
1028    }
1029
1030    ASSERT_NOT_REACHED();
1031    return SINGLE;
1032}
1033
1034template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxOrient e)
1035    : CSSValue(PrimitiveClass)
1036{
1037    m_primitiveUnitType = CSS_VALUE_ID;
1038    switch (e) {
1039    case HORIZONTAL:
1040        m_value.valueID = CSSValueHorizontal;
1041        break;
1042    case VERTICAL:
1043        m_value.valueID = CSSValueVertical;
1044        break;
1045    }
1046}
1047
1048template<> inline CSSPrimitiveValue::operator EBoxOrient() const
1049{
1050    ASSERT(isValueID());
1051
1052    switch (m_value.valueID) {
1053    case CSSValueHorizontal:
1054    case CSSValueInlineAxis:
1055        return HORIZONTAL;
1056    case CSSValueVertical:
1057    case CSSValueBlockAxis:
1058        return VERTICAL;
1059    default:
1060        break;
1061    }
1062
1063    ASSERT_NOT_REACHED();
1064    return HORIZONTAL;
1065}
1066
1067template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ECaptionSide e)
1068    : CSSValue(PrimitiveClass)
1069{
1070    m_primitiveUnitType = CSS_VALUE_ID;
1071    switch (e) {
1072    case CAPLEFT:
1073        m_value.valueID = CSSValueLeft;
1074        break;
1075    case CAPRIGHT:
1076        m_value.valueID = CSSValueRight;
1077        break;
1078    case CAPTOP:
1079        m_value.valueID = CSSValueTop;
1080        break;
1081    case CAPBOTTOM:
1082        m_value.valueID = CSSValueBottom;
1083        break;
1084    }
1085}
1086
1087template<> inline CSSPrimitiveValue::operator ECaptionSide() const
1088{
1089    ASSERT(isValueID());
1090
1091    switch (m_value.valueID) {
1092    case CSSValueLeft:
1093        return CAPLEFT;
1094    case CSSValueRight:
1095        return CAPRIGHT;
1096    case CSSValueTop:
1097        return CAPTOP;
1098    case CSSValueBottom:
1099        return CAPBOTTOM;
1100    default:
1101        break;
1102    }
1103
1104    ASSERT_NOT_REACHED();
1105    return CAPTOP;
1106}
1107
1108template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EClear e)
1109    : CSSValue(PrimitiveClass)
1110{
1111    m_primitiveUnitType = CSS_VALUE_ID;
1112    switch (e) {
1113    case CNONE:
1114        m_value.valueID = CSSValueNone;
1115        break;
1116    case CLEFT:
1117        m_value.valueID = CSSValueLeft;
1118        break;
1119    case CRIGHT:
1120        m_value.valueID = CSSValueRight;
1121        break;
1122    case CBOTH:
1123        m_value.valueID = CSSValueBoth;
1124        break;
1125    }
1126}
1127
1128template<> inline CSSPrimitiveValue::operator EClear() const
1129{
1130    ASSERT(isValueID());
1131
1132    switch (m_value.valueID) {
1133    case CSSValueNone:
1134        return CNONE;
1135    case CSSValueLeft:
1136        return CLEFT;
1137    case CSSValueRight:
1138        return CRIGHT;
1139    case CSSValueBoth:
1140        return CBOTH;
1141    default:
1142        break;
1143    }
1144
1145    ASSERT_NOT_REACHED();
1146    return CNONE;
1147}
1148
1149template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ECursor e)
1150    : CSSValue(PrimitiveClass)
1151{
1152    m_primitiveUnitType = CSS_VALUE_ID;
1153    switch (e) {
1154    case CURSOR_AUTO:
1155        m_value.valueID = CSSValueAuto;
1156        break;
1157    case CURSOR_CROSS:
1158        m_value.valueID = CSSValueCrosshair;
1159        break;
1160    case CURSOR_DEFAULT:
1161        m_value.valueID = CSSValueDefault;
1162        break;
1163    case CURSOR_POINTER:
1164        m_value.valueID = CSSValuePointer;
1165        break;
1166    case CURSOR_MOVE:
1167        m_value.valueID = CSSValueMove;
1168        break;
1169    case CURSOR_CELL:
1170        m_value.valueID = CSSValueCell;
1171        break;
1172    case CURSOR_VERTICAL_TEXT:
1173        m_value.valueID = CSSValueVerticalText;
1174        break;
1175    case CURSOR_CONTEXT_MENU:
1176        m_value.valueID = CSSValueContextMenu;
1177        break;
1178    case CURSOR_ALIAS:
1179        m_value.valueID = CSSValueAlias;
1180        break;
1181    case CURSOR_COPY:
1182        m_value.valueID = CSSValueCopy;
1183        break;
1184    case CURSOR_NONE:
1185        m_value.valueID = CSSValueNone;
1186        break;
1187    case CURSOR_PROGRESS:
1188        m_value.valueID = CSSValueProgress;
1189        break;
1190    case CURSOR_NO_DROP:
1191        m_value.valueID = CSSValueNoDrop;
1192        break;
1193    case CURSOR_NOT_ALLOWED:
1194        m_value.valueID = CSSValueNotAllowed;
1195        break;
1196    case CURSOR_WEBKIT_ZOOM_IN:
1197        m_value.valueID = CSSValueWebkitZoomIn;
1198        break;
1199    case CURSOR_WEBKIT_ZOOM_OUT:
1200        m_value.valueID = CSSValueWebkitZoomOut;
1201        break;
1202    case CURSOR_E_RESIZE:
1203        m_value.valueID = CSSValueEResize;
1204        break;
1205    case CURSOR_NE_RESIZE:
1206        m_value.valueID = CSSValueNeResize;
1207        break;
1208    case CURSOR_NW_RESIZE:
1209        m_value.valueID = CSSValueNwResize;
1210        break;
1211    case CURSOR_N_RESIZE:
1212        m_value.valueID = CSSValueNResize;
1213        break;
1214    case CURSOR_SE_RESIZE:
1215        m_value.valueID = CSSValueSeResize;
1216        break;
1217    case CURSOR_SW_RESIZE:
1218        m_value.valueID = CSSValueSwResize;
1219        break;
1220    case CURSOR_S_RESIZE:
1221        m_value.valueID = CSSValueSResize;
1222        break;
1223    case CURSOR_W_RESIZE:
1224        m_value.valueID = CSSValueWResize;
1225        break;
1226    case CURSOR_EW_RESIZE:
1227        m_value.valueID = CSSValueEwResize;
1228        break;
1229    case CURSOR_NS_RESIZE:
1230        m_value.valueID = CSSValueNsResize;
1231        break;
1232    case CURSOR_NESW_RESIZE:
1233        m_value.valueID = CSSValueNeswResize;
1234        break;
1235    case CURSOR_NWSE_RESIZE:
1236        m_value.valueID = CSSValueNwseResize;
1237        break;
1238    case CURSOR_COL_RESIZE:
1239        m_value.valueID = CSSValueColResize;
1240        break;
1241    case CURSOR_ROW_RESIZE:
1242        m_value.valueID = CSSValueRowResize;
1243        break;
1244    case CURSOR_TEXT:
1245        m_value.valueID = CSSValueText;
1246        break;
1247    case CURSOR_WAIT:
1248        m_value.valueID = CSSValueWait;
1249        break;
1250    case CURSOR_HELP:
1251        m_value.valueID = CSSValueHelp;
1252        break;
1253    case CURSOR_ALL_SCROLL:
1254        m_value.valueID = CSSValueAllScroll;
1255        break;
1256    case CURSOR_WEBKIT_GRAB:
1257        m_value.valueID = CSSValueWebkitGrab;
1258        break;
1259    case CURSOR_WEBKIT_GRABBING:
1260        m_value.valueID = CSSValueWebkitGrabbing;
1261        break;
1262    }
1263}
1264
1265template<> inline CSSPrimitiveValue::operator ECursor() const
1266{
1267    ASSERT(isValueID());
1268
1269    if (m_value.valueID == CSSValueCopy)
1270        return CURSOR_COPY;
1271    if (m_value.valueID == CSSValueNone)
1272        return CURSOR_NONE;
1273    return static_cast<ECursor>(m_value.valueID - CSSValueAuto);
1274}
1275
1276
1277#if ENABLE(CURSOR_VISIBILITY)
1278template<> inline CSSPrimitiveValue::CSSPrimitiveValue(CursorVisibility e)
1279    : CSSValue(PrimitiveClass)
1280{
1281    m_primitiveUnitType = CSS_VALUE_ID;
1282    switch (e) {
1283    case CursorVisibilityAuto:
1284        m_value.valueID = CSSValueAuto;
1285        break;
1286    case CursorVisibilityAutoHide:
1287        m_value.valueID = CSSValueAutoHide;
1288        break;
1289    }
1290}
1291
1292template<> inline CSSPrimitiveValue::operator CursorVisibility() const
1293{
1294    ASSERT(isValueID());
1295
1296    if (m_value.valueID == CSSValueAuto)
1297        return CursorVisibilityAuto;
1298    if (m_value.valueID == CSSValueAutoHide)
1299        return CursorVisibilityAutoHide;
1300
1301    ASSERT_NOT_REACHED();
1302    return CursorVisibilityAuto;
1303}
1304#endif
1305
1306template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EDisplay e)
1307    : CSSValue(PrimitiveClass)
1308{
1309    m_primitiveUnitType = CSS_VALUE_ID;
1310    switch (e) {
1311    case INLINE:
1312        m_value.valueID = CSSValueInline;
1313        break;
1314    case BLOCK:
1315        m_value.valueID = CSSValueBlock;
1316        break;
1317    case LIST_ITEM:
1318        m_value.valueID = CSSValueListItem;
1319        break;
1320    case COMPACT:
1321        m_value.valueID = CSSValueCompact;
1322        break;
1323    case INLINE_BLOCK:
1324        m_value.valueID = CSSValueInlineBlock;
1325        break;
1326    case TABLE:
1327        m_value.valueID = CSSValueTable;
1328        break;
1329    case INLINE_TABLE:
1330        m_value.valueID = CSSValueInlineTable;
1331        break;
1332    case TABLE_ROW_GROUP:
1333        m_value.valueID = CSSValueTableRowGroup;
1334        break;
1335    case TABLE_HEADER_GROUP:
1336        m_value.valueID = CSSValueTableHeaderGroup;
1337        break;
1338    case TABLE_FOOTER_GROUP:
1339        m_value.valueID = CSSValueTableFooterGroup;
1340        break;
1341    case TABLE_ROW:
1342        m_value.valueID = CSSValueTableRow;
1343        break;
1344    case TABLE_COLUMN_GROUP:
1345        m_value.valueID = CSSValueTableColumnGroup;
1346        break;
1347    case TABLE_COLUMN:
1348        m_value.valueID = CSSValueTableColumn;
1349        break;
1350    case TABLE_CELL:
1351        m_value.valueID = CSSValueTableCell;
1352        break;
1353    case TABLE_CAPTION:
1354        m_value.valueID = CSSValueTableCaption;
1355        break;
1356    case BOX:
1357        m_value.valueID = CSSValueWebkitBox;
1358        break;
1359    case INLINE_BOX:
1360        m_value.valueID = CSSValueWebkitInlineBox;
1361        break;
1362    case FLEX:
1363        m_value.valueID = CSSValueWebkitFlex;
1364        break;
1365    case INLINE_FLEX:
1366        m_value.valueID = CSSValueWebkitInlineFlex;
1367        break;
1368#if ENABLE(CSS_GRID_LAYOUT)
1369    case GRID:
1370        m_value.valueID = CSSValueWebkitGrid;
1371        break;
1372    case INLINE_GRID:
1373        m_value.valueID = CSSValueWebkitInlineGrid;
1374        break;
1375#endif
1376    case NONE:
1377        m_value.valueID = CSSValueNone;
1378        break;
1379    }
1380}
1381
1382template<> inline CSSPrimitiveValue::operator EDisplay() const
1383{
1384    ASSERT(isValueID());
1385
1386    if (m_value.valueID == CSSValueNone)
1387        return NONE;
1388
1389    EDisplay display = static_cast<EDisplay>(m_value.valueID - CSSValueInline);
1390    ASSERT(display >= INLINE && display <= NONE);
1391    return display;
1392}
1393
1394template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EEmptyCell e)
1395    : CSSValue(PrimitiveClass)
1396{
1397    m_primitiveUnitType = CSS_VALUE_ID;
1398    switch (e) {
1399    case SHOW:
1400        m_value.valueID = CSSValueShow;
1401        break;
1402    case HIDE:
1403        m_value.valueID = CSSValueHide;
1404        break;
1405    }
1406}
1407
1408template<> inline CSSPrimitiveValue::operator EEmptyCell() const
1409{
1410    ASSERT(isValueID());
1411
1412    switch (m_value.valueID) {
1413    case CSSValueShow:
1414        return SHOW;
1415    case CSSValueHide:
1416        return HIDE;
1417    default:
1418        break;
1419    }
1420
1421    ASSERT_NOT_REACHED();
1422    return SHOW;
1423}
1424
1425template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EAlignItems e)
1426    : CSSValue(PrimitiveClass)
1427{
1428    m_primitiveUnitType = CSS_VALUE_ID;
1429    switch (e) {
1430    case AlignAuto:
1431        m_value.valueID = CSSValueAuto;
1432        break;
1433    case AlignFlexStart:
1434        m_value.valueID = CSSValueFlexStart;
1435        break;
1436    case AlignFlexEnd:
1437        m_value.valueID = CSSValueFlexEnd;
1438        break;
1439    case AlignCenter:
1440        m_value.valueID = CSSValueCenter;
1441        break;
1442    case AlignStretch:
1443        m_value.valueID = CSSValueStretch;
1444        break;
1445    case AlignBaseline:
1446        m_value.valueID = CSSValueBaseline;
1447        break;
1448    }
1449}
1450
1451template<> inline CSSPrimitiveValue::operator EAlignItems() const
1452{
1453    ASSERT(isValueID());
1454
1455    switch (m_value.valueID) {
1456    case CSSValueAuto:
1457        return AlignAuto;
1458    case CSSValueFlexStart:
1459        return AlignFlexStart;
1460    case CSSValueFlexEnd:
1461        return AlignFlexEnd;
1462    case CSSValueCenter:
1463        return AlignCenter;
1464    case CSSValueStretch:
1465        return AlignStretch;
1466    case CSSValueBaseline:
1467        return AlignBaseline;
1468    default:
1469        break;
1470    }
1471
1472    ASSERT_NOT_REACHED();
1473    return AlignFlexStart;
1474}
1475
1476template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EJustifyContent e)
1477    : CSSValue(PrimitiveClass)
1478{
1479    m_primitiveUnitType = CSS_VALUE_ID;
1480    switch (e) {
1481    case JustifyFlexStart:
1482        m_value.valueID = CSSValueFlexStart;
1483        break;
1484    case JustifyFlexEnd:
1485        m_value.valueID = CSSValueFlexEnd;
1486        break;
1487    case JustifyCenter:
1488        m_value.valueID = CSSValueCenter;
1489        break;
1490    case JustifySpaceBetween:
1491        m_value.valueID = CSSValueSpaceBetween;
1492        break;
1493    case JustifySpaceAround:
1494        m_value.valueID = CSSValueSpaceAround;
1495        break;
1496    }
1497}
1498
1499template<> inline CSSPrimitiveValue::operator EJustifyContent() const
1500{
1501    ASSERT(isValueID());
1502
1503    switch (m_value.valueID) {
1504    case CSSValueFlexStart:
1505        return JustifyFlexStart;
1506    case CSSValueFlexEnd:
1507        return JustifyFlexEnd;
1508    case CSSValueCenter:
1509        return JustifyCenter;
1510    case CSSValueSpaceBetween:
1511        return JustifySpaceBetween;
1512    case CSSValueSpaceAround:
1513        return JustifySpaceAround;
1514    default:
1515        break;
1516    }
1517
1518    ASSERT_NOT_REACHED();
1519    return JustifyFlexStart;
1520}
1521
1522template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFlexDirection e)
1523    : CSSValue(PrimitiveClass)
1524{
1525    m_primitiveUnitType = CSS_VALUE_ID;
1526    switch (e) {
1527    case FlowRow:
1528        m_value.valueID = CSSValueRow;
1529        break;
1530    case FlowRowReverse:
1531        m_value.valueID = CSSValueRowReverse;
1532        break;
1533    case FlowColumn:
1534        m_value.valueID = CSSValueColumn;
1535        break;
1536    case FlowColumnReverse:
1537        m_value.valueID = CSSValueColumnReverse;
1538        break;
1539    }
1540}
1541
1542template<> inline CSSPrimitiveValue::operator EFlexDirection() const
1543{
1544    ASSERT(isValueID());
1545
1546    switch (m_value.valueID) {
1547    case CSSValueRow:
1548        return FlowRow;
1549    case CSSValueRowReverse:
1550        return FlowRowReverse;
1551    case CSSValueColumn:
1552        return FlowColumn;
1553    case CSSValueColumnReverse:
1554        return FlowColumnReverse;
1555    default:
1556        break;
1557    }
1558
1559    ASSERT_NOT_REACHED();
1560    return FlowRow;
1561}
1562
1563template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EAlignContent e)
1564    : CSSValue(PrimitiveClass)
1565{
1566    m_primitiveUnitType = CSS_VALUE_ID;
1567    switch (e) {
1568    case AlignContentFlexStart:
1569        m_value.valueID = CSSValueFlexStart;
1570        break;
1571    case AlignContentFlexEnd:
1572        m_value.valueID = CSSValueFlexEnd;
1573        break;
1574    case AlignContentCenter:
1575        m_value.valueID = CSSValueCenter;
1576        break;
1577    case AlignContentSpaceBetween:
1578        m_value.valueID = CSSValueSpaceBetween;
1579        break;
1580    case AlignContentSpaceAround:
1581        m_value.valueID = CSSValueSpaceAround;
1582        break;
1583    case AlignContentStretch:
1584        m_value.valueID = CSSValueStretch;
1585        break;
1586    }
1587}
1588
1589template<> inline CSSPrimitiveValue::operator EAlignContent() const
1590{
1591    ASSERT(isValueID());
1592
1593    switch (m_value.valueID) {
1594    case CSSValueFlexStart:
1595        return AlignContentFlexStart;
1596    case CSSValueFlexEnd:
1597        return AlignContentFlexEnd;
1598    case CSSValueCenter:
1599        return AlignContentCenter;
1600    case CSSValueSpaceBetween:
1601        return AlignContentSpaceBetween;
1602    case CSSValueSpaceAround:
1603        return AlignContentSpaceAround;
1604    case CSSValueStretch:
1605        return AlignContentStretch;
1606    default:
1607        break;
1608    }
1609
1610    ASSERT_NOT_REACHED();
1611    return AlignContentStretch;
1612}
1613
1614template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFlexWrap e)
1615    : CSSValue(PrimitiveClass)
1616{
1617    m_primitiveUnitType = CSS_VALUE_ID;
1618    switch (e) {
1619    case FlexNoWrap:
1620        m_value.valueID = CSSValueNowrap;
1621        break;
1622    case FlexWrap:
1623        m_value.valueID = CSSValueWrap;
1624        break;
1625    case FlexWrapReverse:
1626        m_value.valueID = CSSValueWrapReverse;
1627        break;
1628    }
1629}
1630
1631template<> inline CSSPrimitiveValue::operator EFlexWrap() const
1632{
1633    ASSERT(isValueID());
1634
1635    switch (m_value.valueID) {
1636    case CSSValueNowrap:
1637        return FlexNoWrap;
1638    case CSSValueWrap:
1639        return FlexWrap;
1640    case CSSValueWrapReverse:
1641        return FlexWrapReverse;
1642    default:
1643        break;
1644    }
1645
1646    ASSERT_NOT_REACHED();
1647    return FlexNoWrap;
1648}
1649
1650template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFloat e)
1651    : CSSValue(PrimitiveClass)
1652{
1653    m_primitiveUnitType = CSS_VALUE_ID;
1654    switch (e) {
1655    case NoFloat:
1656        m_value.valueID = CSSValueNone;
1657        break;
1658    case LeftFloat:
1659        m_value.valueID = CSSValueLeft;
1660        break;
1661    case RightFloat:
1662        m_value.valueID = CSSValueRight;
1663        break;
1664    }
1665}
1666
1667template<> inline CSSPrimitiveValue::operator EFloat() const
1668{
1669    ASSERT(isValueID());
1670
1671    switch (m_value.valueID) {
1672    case CSSValueLeft:
1673        return LeftFloat;
1674    case CSSValueRight:
1675        return RightFloat;
1676    case CSSValueNone:
1677    case CSSValueCenter: // Non-standard CSS value.
1678        return NoFloat;
1679    default:
1680        break;
1681    }
1682
1683    ASSERT_NOT_REACHED();
1684    return NoFloat;
1685}
1686
1687template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineBreak e)
1688    : CSSValue(PrimitiveClass)
1689{
1690    m_primitiveUnitType = CSS_VALUE_ID;
1691    switch (e) {
1692    case LineBreakAuto:
1693        m_value.valueID = CSSValueAuto;
1694        break;
1695    case LineBreakLoose:
1696        m_value.valueID = CSSValueLoose;
1697        break;
1698    case LineBreakNormal:
1699        m_value.valueID = CSSValueNormal;
1700        break;
1701    case LineBreakStrict:
1702        m_value.valueID = CSSValueStrict;
1703        break;
1704    case LineBreakAfterWhiteSpace:
1705        m_value.valueID = CSSValueAfterWhiteSpace;
1706        break;
1707    }
1708}
1709
1710template<> inline CSSPrimitiveValue::operator LineBreak() const
1711{
1712    ASSERT(isValueID());
1713
1714    switch (m_value.valueID) {
1715    case CSSValueAuto:
1716        return LineBreakAuto;
1717    case CSSValueLoose:
1718        return LineBreakLoose;
1719    case CSSValueNormal:
1720        return LineBreakNormal;
1721    case CSSValueStrict:
1722        return LineBreakStrict;
1723    case CSSValueAfterWhiteSpace:
1724        return LineBreakAfterWhiteSpace;
1725    default:
1726        break;
1727    }
1728
1729    ASSERT_NOT_REACHED();
1730    return LineBreakAuto;
1731}
1732
1733template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EListStylePosition e)
1734    : CSSValue(PrimitiveClass)
1735{
1736    m_primitiveUnitType = CSS_VALUE_ID;
1737    switch (e) {
1738    case OUTSIDE:
1739        m_value.valueID = CSSValueOutside;
1740        break;
1741    case INSIDE:
1742        m_value.valueID = CSSValueInside;
1743        break;
1744    }
1745}
1746
1747template<> inline CSSPrimitiveValue::operator EListStylePosition() const
1748{
1749    ASSERT(isValueID());
1750
1751    switch (m_value.valueID) {
1752    case CSSValueOutside:
1753        return OUTSIDE;
1754    case CSSValueInside:
1755        return INSIDE;
1756    default:
1757        break;
1758    }
1759
1760    ASSERT_NOT_REACHED();
1761    return OUTSIDE;
1762}
1763
1764template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EListStyleType e)
1765    : CSSValue(PrimitiveClass)
1766{
1767    m_primitiveUnitType = CSS_VALUE_ID;
1768    switch (e) {
1769    case Afar:
1770        m_value.valueID = CSSValueAfar;
1771        break;
1772    case Amharic:
1773        m_value.valueID = CSSValueAmharic;
1774        break;
1775    case AmharicAbegede:
1776        m_value.valueID = CSSValueAmharicAbegede;
1777        break;
1778    case ArabicIndic:
1779        m_value.valueID = CSSValueArabicIndic;
1780        break;
1781    case Armenian:
1782        m_value.valueID = CSSValueArmenian;
1783        break;
1784    case Asterisks:
1785        m_value.valueID = CSSValueAsterisks;
1786        break;
1787    case BinaryListStyle:
1788        m_value.valueID = CSSValueBinary;
1789        break;
1790    case Bengali:
1791        m_value.valueID = CSSValueBengali;
1792        break;
1793    case Cambodian:
1794        m_value.valueID = CSSValueCambodian;
1795        break;
1796    case Circle:
1797        m_value.valueID = CSSValueCircle;
1798        break;
1799    case CjkEarthlyBranch:
1800        m_value.valueID = CSSValueCjkEarthlyBranch;
1801        break;
1802    case CjkHeavenlyStem:
1803        m_value.valueID = CSSValueCjkHeavenlyStem;
1804        break;
1805    case CJKIdeographic:
1806        m_value.valueID = CSSValueCjkIdeographic;
1807        break;
1808    case DecimalLeadingZero:
1809        m_value.valueID = CSSValueDecimalLeadingZero;
1810        break;
1811    case DecimalListStyle:
1812        m_value.valueID = CSSValueDecimal;
1813        break;
1814    case Devanagari:
1815        m_value.valueID = CSSValueDevanagari;
1816        break;
1817    case Disc:
1818        m_value.valueID = CSSValueDisc;
1819        break;
1820    case Ethiopic:
1821        m_value.valueID = CSSValueEthiopic;
1822        break;
1823    case EthiopicAbegede:
1824        m_value.valueID = CSSValueEthiopicAbegede;
1825        break;
1826    case EthiopicAbegedeAmEt:
1827        m_value.valueID = CSSValueEthiopicAbegedeAmEt;
1828        break;
1829    case EthiopicAbegedeGez:
1830        m_value.valueID = CSSValueEthiopicAbegedeGez;
1831        break;
1832    case EthiopicAbegedeTiEr:
1833        m_value.valueID = CSSValueEthiopicAbegedeTiEr;
1834        break;
1835    case EthiopicAbegedeTiEt:
1836        m_value.valueID = CSSValueEthiopicAbegedeTiEt;
1837        break;
1838    case EthiopicHalehameAaEr:
1839        m_value.valueID = CSSValueEthiopicHalehameAaEr;
1840        break;
1841    case EthiopicHalehameAaEt:
1842        m_value.valueID = CSSValueEthiopicHalehameAaEt;
1843        break;
1844    case EthiopicHalehameAmEt:
1845        m_value.valueID = CSSValueEthiopicHalehameAmEt;
1846        break;
1847    case EthiopicHalehameGez:
1848        m_value.valueID = CSSValueEthiopicHalehameGez;
1849        break;
1850    case EthiopicHalehameOmEt:
1851        m_value.valueID = CSSValueEthiopicHalehameOmEt;
1852        break;
1853    case EthiopicHalehameSidEt:
1854        m_value.valueID = CSSValueEthiopicHalehameSidEt;
1855        break;
1856    case EthiopicHalehameSoEt:
1857        m_value.valueID = CSSValueEthiopicHalehameSoEt;
1858        break;
1859    case EthiopicHalehameTiEr:
1860        m_value.valueID = CSSValueEthiopicHalehameTiEr;
1861        break;
1862    case EthiopicHalehameTiEt:
1863        m_value.valueID = CSSValueEthiopicHalehameTiEt;
1864        break;
1865    case EthiopicHalehameTig:
1866        m_value.valueID = CSSValueEthiopicHalehameTig;
1867        break;
1868    case Footnotes:
1869        m_value.valueID = CSSValueFootnotes;
1870        break;
1871    case Georgian:
1872        m_value.valueID = CSSValueGeorgian;
1873        break;
1874    case Gujarati:
1875        m_value.valueID = CSSValueGujarati;
1876        break;
1877    case Gurmukhi:
1878        m_value.valueID = CSSValueGurmukhi;
1879        break;
1880    case Hangul:
1881        m_value.valueID = CSSValueHangul;
1882        break;
1883    case HangulConsonant:
1884        m_value.valueID = CSSValueHangulConsonant;
1885        break;
1886    case Hebrew:
1887        m_value.valueID = CSSValueHebrew;
1888        break;
1889    case Hiragana:
1890        m_value.valueID = CSSValueHiragana;
1891        break;
1892    case HiraganaIroha:
1893        m_value.valueID = CSSValueHiraganaIroha;
1894        break;
1895    case Kannada:
1896        m_value.valueID = CSSValueKannada;
1897        break;
1898    case Katakana:
1899        m_value.valueID = CSSValueKatakana;
1900        break;
1901    case KatakanaIroha:
1902        m_value.valueID = CSSValueKatakanaIroha;
1903        break;
1904    case Khmer:
1905        m_value.valueID = CSSValueKhmer;
1906        break;
1907    case Lao:
1908        m_value.valueID = CSSValueLao;
1909        break;
1910    case LowerAlpha:
1911        m_value.valueID = CSSValueLowerAlpha;
1912        break;
1913    case LowerArmenian:
1914        m_value.valueID = CSSValueLowerArmenian;
1915        break;
1916    case LowerGreek:
1917        m_value.valueID = CSSValueLowerGreek;
1918        break;
1919    case LowerHexadecimal:
1920        m_value.valueID = CSSValueLowerHexadecimal;
1921        break;
1922    case LowerLatin:
1923        m_value.valueID = CSSValueLowerLatin;
1924        break;
1925    case LowerNorwegian:
1926        m_value.valueID = CSSValueLowerNorwegian;
1927        break;
1928    case LowerRoman:
1929        m_value.valueID = CSSValueLowerRoman;
1930        break;
1931    case Malayalam:
1932        m_value.valueID = CSSValueMalayalam;
1933        break;
1934    case Mongolian:
1935        m_value.valueID = CSSValueMongolian;
1936        break;
1937    case Myanmar:
1938        m_value.valueID = CSSValueMyanmar;
1939        break;
1940    case NoneListStyle:
1941        m_value.valueID = CSSValueNone;
1942        break;
1943    case Octal:
1944        m_value.valueID = CSSValueOctal;
1945        break;
1946    case Oriya:
1947        m_value.valueID = CSSValueOriya;
1948        break;
1949    case Oromo:
1950        m_value.valueID = CSSValueOromo;
1951        break;
1952    case Persian:
1953        m_value.valueID = CSSValuePersian;
1954        break;
1955    case Sidama:
1956        m_value.valueID = CSSValueSidama;
1957        break;
1958    case Somali:
1959        m_value.valueID = CSSValueSomali;
1960        break;
1961    case Square:
1962        m_value.valueID = CSSValueSquare;
1963        break;
1964    case Telugu:
1965        m_value.valueID = CSSValueTelugu;
1966        break;
1967    case Thai:
1968        m_value.valueID = CSSValueThai;
1969        break;
1970    case Tibetan:
1971        m_value.valueID = CSSValueTibetan;
1972        break;
1973    case Tigre:
1974        m_value.valueID = CSSValueTigre;
1975        break;
1976    case TigrinyaEr:
1977        m_value.valueID = CSSValueTigrinyaEr;
1978        break;
1979    case TigrinyaErAbegede:
1980        m_value.valueID = CSSValueTigrinyaErAbegede;
1981        break;
1982    case TigrinyaEt:
1983        m_value.valueID = CSSValueTigrinyaEt;
1984        break;
1985    case TigrinyaEtAbegede:
1986        m_value.valueID = CSSValueTigrinyaEtAbegede;
1987        break;
1988    case UpperAlpha:
1989        m_value.valueID = CSSValueUpperAlpha;
1990        break;
1991    case UpperArmenian:
1992        m_value.valueID = CSSValueUpperArmenian;
1993        break;
1994    case UpperGreek:
1995        m_value.valueID = CSSValueUpperGreek;
1996        break;
1997    case UpperHexadecimal:
1998        m_value.valueID = CSSValueUpperHexadecimal;
1999        break;
2000    case UpperLatin:
2001        m_value.valueID = CSSValueUpperLatin;
2002        break;
2003    case UpperNorwegian:
2004        m_value.valueID = CSSValueUpperNorwegian;
2005        break;
2006    case UpperRoman:
2007        m_value.valueID = CSSValueUpperRoman;
2008        break;
2009    case Urdu:
2010        m_value.valueID = CSSValueUrdu;
2011        break;
2012    }
2013}
2014
2015template<> inline CSSPrimitiveValue::operator EListStyleType() const
2016{
2017    ASSERT(isValueID());
2018
2019    switch (m_value.valueID) {
2020    case CSSValueNone:
2021        return NoneListStyle;
2022    default:
2023        return static_cast<EListStyleType>(m_value.valueID - CSSValueDisc);
2024    }
2025}
2026
2027template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EMarginCollapse e)
2028    : CSSValue(PrimitiveClass)
2029{
2030    m_primitiveUnitType = CSS_VALUE_ID;
2031    switch (e) {
2032    case MCOLLAPSE:
2033        m_value.valueID = CSSValueCollapse;
2034        break;
2035    case MSEPARATE:
2036        m_value.valueID = CSSValueSeparate;
2037        break;
2038    case MDISCARD:
2039        m_value.valueID = CSSValueDiscard;
2040        break;
2041    }
2042}
2043
2044template<> inline CSSPrimitiveValue::operator EMarginCollapse() const
2045{
2046    ASSERT(isValueID());
2047
2048    switch (m_value.valueID) {
2049    case CSSValueCollapse:
2050        return MCOLLAPSE;
2051    case CSSValueSeparate:
2052        return MSEPARATE;
2053    case CSSValueDiscard:
2054        return MDISCARD;
2055    default:
2056        break;
2057    }
2058
2059    ASSERT_NOT_REACHED();
2060    return MCOLLAPSE;
2061}
2062
2063template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EMarqueeBehavior e)
2064    : CSSValue(PrimitiveClass)
2065{
2066    m_primitiveUnitType = CSS_VALUE_ID;
2067    switch (e) {
2068    case MNONE:
2069        m_value.valueID = CSSValueNone;
2070        break;
2071    case MSCROLL:
2072        m_value.valueID = CSSValueScroll;
2073        break;
2074    case MSLIDE:
2075        m_value.valueID = CSSValueSlide;
2076        break;
2077    case MALTERNATE:
2078        m_value.valueID = CSSValueAlternate;
2079        break;
2080    }
2081}
2082
2083template<> inline CSSPrimitiveValue::operator EMarqueeBehavior() const
2084{
2085    ASSERT(isValueID());
2086
2087    switch (m_value.valueID) {
2088    case CSSValueNone:
2089        return MNONE;
2090    case CSSValueScroll:
2091        return MSCROLL;
2092    case CSSValueSlide:
2093        return MSLIDE;
2094    case CSSValueAlternate:
2095        return MALTERNATE;
2096    default:
2097        break;
2098    }
2099
2100    ASSERT_NOT_REACHED();
2101    return MNONE;
2102}
2103
2104template<> inline CSSPrimitiveValue::CSSPrimitiveValue(RegionFragment e)
2105    : CSSValue(PrimitiveClass)
2106{
2107    m_primitiveUnitType = CSS_VALUE_ID;
2108    switch (e) {
2109    case AutoRegionFragment:
2110        m_value.valueID = CSSValueAuto;
2111        break;
2112    case BreakRegionFragment:
2113        m_value.valueID = CSSValueBreak;
2114        break;
2115    }
2116}
2117
2118template<> inline CSSPrimitiveValue::operator RegionFragment() const
2119{
2120    ASSERT(isValueID());
2121
2122    switch (m_value.valueID) {
2123    case CSSValueAuto:
2124        return AutoRegionFragment;
2125    case CSSValueBreak:
2126        return BreakRegionFragment;
2127    default:
2128        break;
2129    }
2130
2131    ASSERT_NOT_REACHED();
2132    return AutoRegionFragment;
2133}
2134
2135template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EMarqueeDirection e)
2136    : CSSValue(PrimitiveClass)
2137{
2138    m_primitiveUnitType = CSS_VALUE_ID;
2139    switch (e) {
2140    case MFORWARD:
2141        m_value.valueID = CSSValueForwards;
2142        break;
2143    case MBACKWARD:
2144        m_value.valueID = CSSValueBackwards;
2145        break;
2146    case MAUTO:
2147        m_value.valueID = CSSValueAuto;
2148        break;
2149    case MUP:
2150        m_value.valueID = CSSValueUp;
2151        break;
2152    case MDOWN:
2153        m_value.valueID = CSSValueDown;
2154        break;
2155    case MLEFT:
2156        m_value.valueID = CSSValueLeft;
2157        break;
2158    case MRIGHT:
2159        m_value.valueID = CSSValueRight;
2160        break;
2161    }
2162}
2163
2164template<> inline CSSPrimitiveValue::operator EMarqueeDirection() const
2165{
2166    ASSERT(isValueID());
2167
2168    switch (m_value.valueID) {
2169    case CSSValueForwards:
2170        return MFORWARD;
2171    case CSSValueBackwards:
2172        return MBACKWARD;
2173    case CSSValueAuto:
2174        return MAUTO;
2175    case CSSValueAhead:
2176    case CSSValueUp: // We don't support vertical languages, so AHEAD just maps to UP.
2177        return MUP;
2178    case CSSValueReverse:
2179    case CSSValueDown: // REVERSE just maps to DOWN, since we don't do vertical text.
2180        return MDOWN;
2181    case CSSValueLeft:
2182        return MLEFT;
2183    case CSSValueRight:
2184        return MRIGHT;
2185    default:
2186        break;
2187    }
2188
2189    ASSERT_NOT_REACHED();
2190    return MAUTO;
2191}
2192
2193template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ENBSPMode e)
2194    : CSSValue(PrimitiveClass)
2195{
2196    m_primitiveUnitType = CSS_VALUE_ID;
2197    switch (e) {
2198    case NBNORMAL:
2199        m_value.valueID = CSSValueNormal;
2200        break;
2201    case SPACE:
2202        m_value.valueID = CSSValueSpace;
2203        break;
2204    }
2205}
2206
2207template<> inline CSSPrimitiveValue::operator ENBSPMode() const
2208{
2209    ASSERT(isValueID());
2210
2211    switch (m_value.valueID) {
2212    case CSSValueSpace:
2213        return SPACE;
2214    case CSSValueNormal:
2215        return NBNORMAL;
2216    default:
2217        break;
2218    }
2219
2220    ASSERT_NOT_REACHED();
2221    return NBNORMAL;
2222}
2223
2224template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EOverflow e)
2225    : CSSValue(PrimitiveClass)
2226{
2227    m_primitiveUnitType = CSS_VALUE_ID;
2228    switch (e) {
2229    case OVISIBLE:
2230        m_value.valueID = CSSValueVisible;
2231        break;
2232    case OHIDDEN:
2233        m_value.valueID = CSSValueHidden;
2234        break;
2235    case OSCROLL:
2236        m_value.valueID = CSSValueScroll;
2237        break;
2238    case OAUTO:
2239        m_value.valueID = CSSValueAuto;
2240        break;
2241    case OMARQUEE:
2242        m_value.valueID = CSSValueWebkitMarquee;
2243        break;
2244    case OOVERLAY:
2245        m_value.valueID = CSSValueOverlay;
2246        break;
2247    case OPAGEDX:
2248        m_value.valueID = CSSValueWebkitPagedX;
2249        break;
2250    case OPAGEDY:
2251        m_value.valueID = CSSValueWebkitPagedY;
2252        break;
2253    }
2254}
2255
2256template<> inline CSSPrimitiveValue::operator EOverflow() const
2257{
2258    ASSERT(isValueID());
2259
2260    switch (m_value.valueID) {
2261    case CSSValueVisible:
2262        return OVISIBLE;
2263    case CSSValueHidden:
2264        return OHIDDEN;
2265    case CSSValueScroll:
2266        return OSCROLL;
2267    case CSSValueAuto:
2268        return OAUTO;
2269    case CSSValueWebkitMarquee:
2270        return OMARQUEE;
2271    case CSSValueOverlay:
2272        return OOVERLAY;
2273    case CSSValueWebkitPagedX:
2274        return OPAGEDX;
2275    case CSSValueWebkitPagedY:
2276        return OPAGEDY;
2277    default:
2278        break;
2279    }
2280
2281    ASSERT_NOT_REACHED();
2282    return OVISIBLE;
2283}
2284
2285template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EPageBreak e)
2286    : CSSValue(PrimitiveClass)
2287{
2288    m_primitiveUnitType = CSS_VALUE_ID;
2289    switch (e) {
2290    case PBAUTO:
2291        m_value.valueID = CSSValueAuto;
2292        break;
2293    case PBALWAYS:
2294        m_value.valueID = CSSValueAlways;
2295        break;
2296    case PBAVOID:
2297        m_value.valueID = CSSValueAvoid;
2298        break;
2299    }
2300}
2301
2302template<> inline CSSPrimitiveValue::operator EPageBreak() const
2303{
2304    ASSERT(isValueID());
2305
2306    switch (m_value.valueID) {
2307    case CSSValueAuto:
2308        return PBAUTO;
2309    case CSSValueLeft:
2310    case CSSValueRight:
2311    case CSSValueAlways:
2312        return PBALWAYS; // CSS2.1: "Conforming user agents may map left/right to always."
2313    case CSSValueAvoid:
2314        return PBAVOID;
2315    default:
2316        break;
2317    }
2318
2319    ASSERT_NOT_REACHED();
2320    return PBAUTO;
2321}
2322
2323template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EPosition e)
2324    : CSSValue(PrimitiveClass)
2325{
2326    m_primitiveUnitType = CSS_VALUE_ID;
2327    switch (e) {
2328    case StaticPosition:
2329        m_value.valueID = CSSValueStatic;
2330        break;
2331    case RelativePosition:
2332        m_value.valueID = CSSValueRelative;
2333        break;
2334    case AbsolutePosition:
2335        m_value.valueID = CSSValueAbsolute;
2336        break;
2337    case FixedPosition:
2338        m_value.valueID = CSSValueFixed;
2339        break;
2340    case StickyPosition:
2341        m_value.valueID = CSSValueWebkitSticky;
2342        break;
2343    }
2344}
2345
2346template<> inline CSSPrimitiveValue::operator EPosition() const
2347{
2348    ASSERT(isValueID());
2349
2350    switch (m_value.valueID) {
2351    case CSSValueStatic:
2352        return StaticPosition;
2353    case CSSValueRelative:
2354        return RelativePosition;
2355    case CSSValueAbsolute:
2356        return AbsolutePosition;
2357    case CSSValueFixed:
2358        return FixedPosition;
2359    case CSSValueWebkitSticky:
2360        return StickyPosition;
2361    default:
2362        break;
2363    }
2364
2365    ASSERT_NOT_REACHED();
2366    return StaticPosition;
2367}
2368
2369template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EResize e)
2370    : CSSValue(PrimitiveClass)
2371{
2372    m_primitiveUnitType = CSS_VALUE_ID;
2373    switch (e) {
2374    case RESIZE_BOTH:
2375        m_value.valueID = CSSValueBoth;
2376        break;
2377    case RESIZE_HORIZONTAL:
2378        m_value.valueID = CSSValueHorizontal;
2379        break;
2380    case RESIZE_VERTICAL:
2381        m_value.valueID = CSSValueVertical;
2382        break;
2383    case RESIZE_NONE:
2384        m_value.valueID = CSSValueNone;
2385        break;
2386    }
2387}
2388
2389template<> inline CSSPrimitiveValue::operator EResize() const
2390{
2391    ASSERT(isValueID());
2392
2393    switch (m_value.valueID) {
2394    case CSSValueBoth:
2395        return RESIZE_BOTH;
2396    case CSSValueHorizontal:
2397        return RESIZE_HORIZONTAL;
2398    case CSSValueVertical:
2399        return RESIZE_VERTICAL;
2400    case CSSValueAuto:
2401        ASSERT_NOT_REACHED(); // Depends on settings, thus should be handled by the caller.
2402        return RESIZE_NONE;
2403    case CSSValueNone:
2404        return RESIZE_NONE;
2405    default:
2406        break;
2407    }
2408
2409    ASSERT_NOT_REACHED();
2410    return RESIZE_NONE;
2411}
2412
2413template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETableLayout e)
2414    : CSSValue(PrimitiveClass)
2415{
2416    m_primitiveUnitType = CSS_VALUE_ID;
2417    switch (e) {
2418    case TAUTO:
2419        m_value.valueID = CSSValueAuto;
2420        break;
2421    case TFIXED:
2422        m_value.valueID = CSSValueFixed;
2423        break;
2424    }
2425}
2426
2427template<> inline CSSPrimitiveValue::operator ETableLayout() const
2428{
2429    ASSERT(isValueID());
2430
2431    switch (m_value.valueID) {
2432    case CSSValueFixed:
2433        return TFIXED;
2434    case CSSValueAuto:
2435        return TAUTO;
2436    default:
2437        break;
2438    }
2439
2440    ASSERT_NOT_REACHED();
2441    return TAUTO;
2442}
2443
2444template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETextAlign e)
2445    : CSSValue(PrimitiveClass)
2446{
2447    m_primitiveUnitType = CSS_VALUE_ID;
2448    switch (e) {
2449    case TASTART:
2450        m_value.valueID = CSSValueStart;
2451        break;
2452    case TAEND:
2453        m_value.valueID = CSSValueEnd;
2454        break;
2455    case LEFT:
2456        m_value.valueID = CSSValueLeft;
2457        break;
2458    case RIGHT:
2459        m_value.valueID = CSSValueRight;
2460        break;
2461    case CENTER:
2462        m_value.valueID = CSSValueCenter;
2463        break;
2464    case JUSTIFY:
2465        m_value.valueID = CSSValueJustify;
2466        break;
2467    case WEBKIT_LEFT:
2468        m_value.valueID = CSSValueWebkitLeft;
2469        break;
2470    case WEBKIT_RIGHT:
2471        m_value.valueID = CSSValueWebkitRight;
2472        break;
2473    case WEBKIT_CENTER:
2474        m_value.valueID = CSSValueWebkitCenter;
2475        break;
2476    }
2477}
2478
2479template<> inline CSSPrimitiveValue::operator ETextAlign() const
2480{
2481    ASSERT(isValueID());
2482
2483    switch (m_value.valueID) {
2484    case CSSValueWebkitAuto: // Legacy -webkit-auto. Eqiuvalent to start.
2485    case CSSValueStart:
2486        return TASTART;
2487    case CSSValueEnd:
2488        return TAEND;
2489    default:
2490        return static_cast<ETextAlign>(m_value.valueID - CSSValueLeft);
2491    }
2492}
2493
2494#if ENABLE(CSS3_TEXT)
2495template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextAlignLast e)
2496    : CSSValue(PrimitiveClass)
2497{
2498    m_primitiveUnitType = CSS_VALUE_ID;
2499    switch (e) {
2500    case TextAlignLastStart:
2501        m_value.valueID = CSSValueStart;
2502        break;
2503    case TextAlignLastEnd:
2504        m_value.valueID = CSSValueEnd;
2505        break;
2506    case TextAlignLastLeft:
2507        m_value.valueID = CSSValueLeft;
2508        break;
2509    case TextAlignLastRight:
2510        m_value.valueID = CSSValueRight;
2511        break;
2512    case TextAlignLastCenter:
2513        m_value.valueID = CSSValueCenter;
2514        break;
2515    case TextAlignLastJustify:
2516        m_value.valueID = CSSValueJustify;
2517        break;
2518    case TextAlignLastAuto:
2519        m_value.valueID = CSSValueAuto;
2520        break;
2521    }
2522}
2523
2524template<> inline CSSPrimitiveValue::operator TextAlignLast() const
2525{
2526    ASSERT(isValueID());
2527
2528    switch (m_value.valueID) {
2529    case CSSValueAuto:
2530        return TextAlignLastAuto;
2531    case CSSValueStart:
2532        return TextAlignLastStart;
2533    case CSSValueEnd:
2534        return TextAlignLastEnd;
2535    case CSSValueLeft:
2536        return TextAlignLastLeft;
2537    case CSSValueRight:
2538        return TextAlignLastRight;
2539    case CSSValueCenter:
2540        return TextAlignLastCenter;
2541    case CSSValueJustify:
2542        return TextAlignLastJustify;
2543    default:
2544        break;
2545    }
2546
2547    ASSERT_NOT_REACHED();
2548    return TextAlignLastAuto;
2549}
2550
2551template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextJustify e)
2552    : CSSValue(PrimitiveClass)
2553{
2554    m_primitiveUnitType = CSS_VALUE_ID;
2555    switch (e) {
2556    case TextJustifyAuto:
2557        m_value.valueID = CSSValueAuto;
2558        break;
2559    case TextJustifyNone:
2560        m_value.valueID = CSSValueNone;
2561        break;
2562    case TextJustifyInterWord:
2563        m_value.valueID = CSSValueInterWord;
2564        break;
2565    case TextJustifyInterIdeograph:
2566        m_value.valueID = CSSValueInterIdeograph;
2567        break;
2568    case TextJustifyInterCluster:
2569        m_value.valueID = CSSValueInterCluster;
2570        break;
2571    case TextJustifyDistribute:
2572        m_value.valueID = CSSValueDistribute;
2573        break;
2574    case TextJustifyKashida:
2575        m_value.valueID = CSSValueKashida;
2576        break;
2577    }
2578}
2579
2580template<> inline CSSPrimitiveValue::operator TextJustify() const
2581{
2582    ASSERT(isValueID());
2583
2584    switch (m_value.valueID) {
2585    case CSSValueAuto:
2586        return TextJustifyAuto;
2587    case CSSValueNone:
2588        return TextJustifyNone;
2589    case CSSValueInterWord:
2590        return TextJustifyInterWord;
2591    case CSSValueInterIdeograph:
2592        return TextJustifyInterIdeograph;
2593    case CSSValueInterCluster:
2594        return TextJustifyInterCluster;
2595    case CSSValueDistribute:
2596        return TextJustifyDistribute;
2597    case CSSValueKashida:
2598        return TextJustifyKashida;
2599    default:
2600        break;
2601    }
2602
2603    ASSERT_NOT_REACHED();
2604    return TextJustifyAuto;
2605}
2606#endif // CSS3_TEXT
2607
2608template<> inline CSSPrimitiveValue::operator TextDecoration() const
2609{
2610    ASSERT(isValueID());
2611
2612    switch (m_value.valueID) {
2613    case CSSValueNone:
2614        return TextDecorationNone;
2615    case CSSValueUnderline:
2616        return TextDecorationUnderline;
2617    case CSSValueOverline:
2618        return TextDecorationOverline;
2619    case CSSValueLineThrough:
2620        return TextDecorationLineThrough;
2621    case CSSValueBlink:
2622        return TextDecorationBlink;
2623#if ENABLE(LETTERPRESS)
2624    case CSSValueWebkitLetterpress:
2625        return TextDecorationLetterpress;
2626#endif
2627    default:
2628        break;
2629    }
2630
2631    ASSERT_NOT_REACHED();
2632    return TextDecorationNone;
2633}
2634
2635template<> inline CSSPrimitiveValue::operator TextDecorationStyle() const
2636{
2637    ASSERT(isValueID());
2638
2639    switch (m_value.valueID) {
2640    case CSSValueSolid:
2641        return TextDecorationStyleSolid;
2642    case CSSValueDouble:
2643        return TextDecorationStyleDouble;
2644    case CSSValueDotted:
2645        return TextDecorationStyleDotted;
2646    case CSSValueDashed:
2647        return TextDecorationStyleDashed;
2648    case CSSValueWavy:
2649        return TextDecorationStyleWavy;
2650    default:
2651        break;
2652    }
2653
2654    ASSERT_NOT_REACHED();
2655    return TextDecorationStyleSolid;
2656}
2657
2658template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextUnderlinePosition e)
2659    : CSSValue(PrimitiveClass)
2660{
2661    m_primitiveUnitType = CSS_VALUE_ID;
2662    switch (e) {
2663    case TextUnderlinePositionAuto:
2664        m_value.valueID = CSSValueAuto;
2665        break;
2666    case TextUnderlinePositionAlphabetic:
2667        m_value.valueID = CSSValueAlphabetic;
2668        break;
2669    case TextUnderlinePositionUnder:
2670        m_value.valueID = CSSValueUnder;
2671        break;
2672    }
2673
2674    // FIXME: Implement support for 'under left' and 'under right' values.
2675}
2676
2677template<> inline CSSPrimitiveValue::operator TextUnderlinePosition() const
2678{
2679    ASSERT(isValueID());
2680
2681    switch (m_value.valueID) {
2682    case CSSValueAuto:
2683        return TextUnderlinePositionAuto;
2684    case CSSValueAlphabetic:
2685        return TextUnderlinePositionAlphabetic;
2686    case CSSValueUnder:
2687        return TextUnderlinePositionUnder;
2688    default:
2689        break;
2690    }
2691
2692    // FIXME: Implement support for 'under left' and 'under right' values.
2693
2694    ASSERT_NOT_REACHED();
2695    return TextUnderlinePositionAuto;
2696}
2697
2698template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETextSecurity e)
2699    : CSSValue(PrimitiveClass)
2700{
2701    m_primitiveUnitType = CSS_VALUE_ID;
2702    switch (e) {
2703    case TSNONE:
2704        m_value.valueID = CSSValueNone;
2705        break;
2706    case TSDISC:
2707        m_value.valueID = CSSValueDisc;
2708        break;
2709    case TSCIRCLE:
2710        m_value.valueID = CSSValueCircle;
2711        break;
2712    case TSSQUARE:
2713        m_value.valueID = CSSValueSquare;
2714        break;
2715    }
2716}
2717
2718template<> inline CSSPrimitiveValue::operator ETextSecurity() const
2719{
2720    ASSERT(isValueID());
2721
2722    switch (m_value.valueID) {
2723    case CSSValueNone:
2724        return TSNONE;
2725    case CSSValueDisc:
2726        return TSDISC;
2727    case CSSValueCircle:
2728        return TSCIRCLE;
2729    case CSSValueSquare:
2730        return TSSQUARE;
2731    default:
2732        break;
2733    }
2734
2735    ASSERT_NOT_REACHED();
2736    return TSNONE;
2737}
2738
2739template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETextTransform e)
2740    : CSSValue(PrimitiveClass)
2741{
2742    m_primitiveUnitType = CSS_VALUE_ID;
2743    switch (e) {
2744    case CAPITALIZE:
2745        m_value.valueID = CSSValueCapitalize;
2746        break;
2747    case UPPERCASE:
2748        m_value.valueID = CSSValueUppercase;
2749        break;
2750    case LOWERCASE:
2751        m_value.valueID = CSSValueLowercase;
2752        break;
2753    case TTNONE:
2754        m_value.valueID = CSSValueNone;
2755        break;
2756    }
2757}
2758
2759template<> inline CSSPrimitiveValue::operator ETextTransform() const
2760{
2761    ASSERT(isValueID());
2762
2763    switch (m_value.valueID) {
2764    case CSSValueCapitalize:
2765        return CAPITALIZE;
2766    case CSSValueUppercase:
2767        return UPPERCASE;
2768    case CSSValueLowercase:
2769        return LOWERCASE;
2770    case CSSValueNone:
2771        return TTNONE;
2772    default:
2773        break;
2774    }
2775
2776    ASSERT_NOT_REACHED();
2777    return TTNONE;
2778}
2779
2780template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUnicodeBidi e)
2781    : CSSValue(PrimitiveClass)
2782{
2783    m_primitiveUnitType = CSS_VALUE_ID;
2784    switch (e) {
2785    case UBNormal:
2786        m_value.valueID = CSSValueNormal;
2787        break;
2788    case Embed:
2789        m_value.valueID = CSSValueEmbed;
2790        break;
2791    case Override:
2792        m_value.valueID = CSSValueBidiOverride;
2793        break;
2794    case Isolate:
2795        m_value.valueID = CSSValueWebkitIsolate;
2796        break;
2797    case IsolateOverride:
2798        m_value.valueID = CSSValueWebkitIsolateOverride;
2799        break;
2800    case Plaintext:
2801        m_value.valueID = CSSValueWebkitPlaintext;
2802        break;
2803    }
2804}
2805
2806template<> inline CSSPrimitiveValue::operator EUnicodeBidi() const
2807{
2808    ASSERT(isValueID());
2809
2810    switch (m_value.valueID) {
2811    case CSSValueNormal:
2812        return UBNormal;
2813    case CSSValueEmbed:
2814        return Embed;
2815    case CSSValueBidiOverride:
2816        return Override;
2817    case CSSValueWebkitIsolate:
2818        return Isolate;
2819    case CSSValueWebkitIsolateOverride:
2820        return IsolateOverride;
2821    case CSSValueWebkitPlaintext:
2822        return Plaintext;
2823    default:
2824        break;
2825    }
2826
2827    ASSERT_NOT_REACHED();
2828    return UBNormal;
2829}
2830
2831template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUserDrag e)
2832    : CSSValue(PrimitiveClass)
2833{
2834    m_primitiveUnitType = CSS_VALUE_ID;
2835    switch (e) {
2836    case DRAG_AUTO:
2837        m_value.valueID = CSSValueAuto;
2838        break;
2839    case DRAG_NONE:
2840        m_value.valueID = CSSValueNone;
2841        break;
2842    case DRAG_ELEMENT:
2843        m_value.valueID = CSSValueElement;
2844        break;
2845    default:
2846        break;
2847    }
2848}
2849
2850template<> inline CSSPrimitiveValue::operator EUserDrag() const
2851{
2852    ASSERT(isValueID());
2853
2854    switch (m_value.valueID) {
2855    case CSSValueAuto:
2856        return DRAG_AUTO;
2857    case CSSValueNone:
2858        return DRAG_NONE;
2859    case CSSValueElement:
2860        return DRAG_ELEMENT;
2861    default:
2862        break;
2863    }
2864
2865    ASSERT_NOT_REACHED();
2866    return DRAG_AUTO;
2867}
2868
2869template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUserModify e)
2870    : CSSValue(PrimitiveClass)
2871{
2872    m_primitiveUnitType = CSS_VALUE_ID;
2873    switch (e) {
2874    case READ_ONLY:
2875        m_value.valueID = CSSValueReadOnly;
2876        break;
2877    case READ_WRITE:
2878        m_value.valueID = CSSValueReadWrite;
2879        break;
2880    case READ_WRITE_PLAINTEXT_ONLY:
2881        m_value.valueID = CSSValueReadWritePlaintextOnly;
2882        break;
2883    }
2884}
2885
2886template<> inline CSSPrimitiveValue::operator EUserModify() const
2887{
2888    ASSERT(isValueID());
2889
2890    switch (m_value.valueID) {
2891    case CSSValueReadOnly:
2892        return READ_ONLY;
2893    case CSSValueReadWrite:
2894        return READ_WRITE;
2895    case CSSValueReadWritePlaintextOnly:
2896        return READ_WRITE_PLAINTEXT_ONLY;
2897    default:
2898        break;
2899    }
2900
2901    ASSERT_NOT_REACHED();
2902    return READ_ONLY;
2903}
2904
2905template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUserSelect e)
2906    : CSSValue(PrimitiveClass)
2907{
2908    m_primitiveUnitType = CSS_VALUE_ID;
2909    switch (e) {
2910    case SELECT_NONE:
2911        m_value.valueID = CSSValueNone;
2912        break;
2913    case SELECT_TEXT:
2914        m_value.valueID = CSSValueText;
2915        break;
2916    case SELECT_ALL:
2917        m_value.valueID = CSSValueAll;
2918        break;
2919    }
2920}
2921
2922template<> inline CSSPrimitiveValue::operator EUserSelect() const
2923{
2924    ASSERT(isValueID());
2925
2926    switch (m_value.valueID) {
2927    case CSSValueAuto:
2928        return SELECT_TEXT;
2929    case CSSValueNone:
2930        return SELECT_NONE;
2931    case CSSValueText:
2932        return SELECT_TEXT;
2933    case CSSValueAll:
2934        return SELECT_ALL;
2935    default:
2936        break;
2937    }
2938
2939    ASSERT_NOT_REACHED();
2940    return SELECT_TEXT;
2941}
2942
2943template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EVerticalAlign a)
2944    : CSSValue(PrimitiveClass)
2945{
2946    m_primitiveUnitType = CSS_VALUE_ID;
2947    switch (a) {
2948    case TOP:
2949        m_value.valueID = CSSValueTop;
2950        break;
2951    case BOTTOM:
2952        m_value.valueID = CSSValueBottom;
2953        break;
2954    case MIDDLE:
2955        m_value.valueID = CSSValueMiddle;
2956        break;
2957    case BASELINE:
2958        m_value.valueID = CSSValueBaseline;
2959        break;
2960    case TEXT_BOTTOM:
2961        m_value.valueID = CSSValueTextBottom;
2962        break;
2963    case TEXT_TOP:
2964        m_value.valueID = CSSValueTextTop;
2965        break;
2966    case SUB:
2967        m_value.valueID = CSSValueSub;
2968        break;
2969    case SUPER:
2970        m_value.valueID = CSSValueSuper;
2971        break;
2972    case BASELINE_MIDDLE:
2973        m_value.valueID = CSSValueWebkitBaselineMiddle;
2974        break;
2975    case LENGTH:
2976        m_value.valueID = CSSValueInvalid;
2977    }
2978}
2979
2980template<> inline CSSPrimitiveValue::operator EVerticalAlign() const
2981{
2982    ASSERT(isValueID());
2983
2984    switch (m_value.valueID) {
2985    case CSSValueTop:
2986        return TOP;
2987    case CSSValueBottom:
2988        return BOTTOM;
2989    case CSSValueMiddle:
2990        return MIDDLE;
2991    case CSSValueBaseline:
2992        return BASELINE;
2993    case CSSValueTextBottom:
2994        return TEXT_BOTTOM;
2995    case CSSValueTextTop:
2996        return TEXT_TOP;
2997    case CSSValueSub:
2998        return SUB;
2999    case CSSValueSuper:
3000        return SUPER;
3001    case CSSValueWebkitBaselineMiddle:
3002        return BASELINE_MIDDLE;
3003    default:
3004        break;
3005    }
3006
3007    ASSERT_NOT_REACHED();
3008    return TOP;
3009}
3010
3011template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EVisibility e)
3012    : CSSValue(PrimitiveClass)
3013{
3014    m_primitiveUnitType = CSS_VALUE_ID;
3015    switch (e) {
3016    case VISIBLE:
3017        m_value.valueID = CSSValueVisible;
3018        break;
3019    case HIDDEN:
3020        m_value.valueID = CSSValueHidden;
3021        break;
3022    case COLLAPSE:
3023        m_value.valueID = CSSValueCollapse;
3024        break;
3025    }
3026}
3027
3028template<> inline CSSPrimitiveValue::operator EVisibility() const
3029{
3030    ASSERT(isValueID());
3031
3032    switch (m_value.valueID) {
3033    case CSSValueHidden:
3034        return HIDDEN;
3035    case CSSValueVisible:
3036        return VISIBLE;
3037    case CSSValueCollapse:
3038        return COLLAPSE;
3039    default:
3040        break;
3041    }
3042
3043    ASSERT_NOT_REACHED();
3044    return VISIBLE;
3045}
3046
3047template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EWhiteSpace e)
3048    : CSSValue(PrimitiveClass)
3049{
3050    m_primitiveUnitType = CSS_VALUE_ID;
3051    switch (e) {
3052    case NORMAL:
3053        m_value.valueID = CSSValueNormal;
3054        break;
3055    case PRE:
3056        m_value.valueID = CSSValuePre;
3057        break;
3058    case PRE_WRAP:
3059        m_value.valueID = CSSValuePreWrap;
3060        break;
3061    case PRE_LINE:
3062        m_value.valueID = CSSValuePreLine;
3063        break;
3064    case NOWRAP:
3065        m_value.valueID = CSSValueNowrap;
3066        break;
3067    case KHTML_NOWRAP:
3068        m_value.valueID = CSSValueWebkitNowrap;
3069        break;
3070    }
3071}
3072
3073template<> inline CSSPrimitiveValue::operator EWhiteSpace() const
3074{
3075    ASSERT(isValueID());
3076
3077    switch (m_value.valueID) {
3078    case CSSValueWebkitNowrap:
3079        return KHTML_NOWRAP;
3080    case CSSValueNowrap:
3081        return NOWRAP;
3082    case CSSValuePre:
3083        return PRE;
3084    case CSSValuePreWrap:
3085        return PRE_WRAP;
3086    case CSSValuePreLine:
3087        return PRE_LINE;
3088    case CSSValueNormal:
3089        return NORMAL;
3090    default:
3091        break;
3092    }
3093
3094    ASSERT_NOT_REACHED();
3095    return NORMAL;
3096}
3097
3098template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EWordBreak e)
3099    : CSSValue(PrimitiveClass)
3100{
3101    m_primitiveUnitType = CSS_VALUE_ID;
3102    switch (e) {
3103    case NormalWordBreak:
3104        m_value.valueID = CSSValueNormal;
3105        break;
3106    case BreakAllWordBreak:
3107        m_value.valueID = CSSValueBreakAll;
3108        break;
3109    case BreakWordBreak:
3110        m_value.valueID = CSSValueBreakWord;
3111        break;
3112    }
3113}
3114
3115template<> inline CSSPrimitiveValue::operator EWordBreak() const
3116{
3117    ASSERT(isValueID());
3118
3119    switch (m_value.valueID) {
3120    case CSSValueBreakAll:
3121        return BreakAllWordBreak;
3122    case CSSValueBreakWord:
3123        return BreakWordBreak;
3124    case CSSValueNormal:
3125        return NormalWordBreak;
3126    default:
3127        break;
3128    }
3129
3130    ASSERT_NOT_REACHED();
3131    return NormalWordBreak;
3132}
3133
3134template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EOverflowWrap e)
3135    : CSSValue(PrimitiveClass)
3136{
3137    m_primitiveUnitType = CSS_VALUE_ID;
3138    switch (e) {
3139    case NormalOverflowWrap:
3140        m_value.valueID = CSSValueNormal;
3141        break;
3142    case BreakOverflowWrap:
3143        m_value.valueID = CSSValueBreakWord;
3144        break;
3145    }
3146}
3147
3148template<> inline CSSPrimitiveValue::operator EOverflowWrap() const
3149{
3150    ASSERT(isValueID());
3151
3152    switch (m_value.valueID) {
3153    case CSSValueBreakWord:
3154        return BreakOverflowWrap;
3155    case CSSValueNormal:
3156        return NormalOverflowWrap;
3157    default:
3158        break;
3159    }
3160
3161    ASSERT_NOT_REACHED();
3162    return NormalOverflowWrap;
3163}
3164
3165template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextDirection e)
3166    : CSSValue(PrimitiveClass)
3167{
3168    m_primitiveUnitType = CSS_VALUE_ID;
3169    switch (e) {
3170    case LTR:
3171        m_value.valueID = CSSValueLtr;
3172        break;
3173    case RTL:
3174        m_value.valueID = CSSValueRtl;
3175        break;
3176    }
3177}
3178
3179template<> inline CSSPrimitiveValue::operator TextDirection() const
3180{
3181    ASSERT(isValueID());
3182
3183    switch (m_value.valueID) {
3184    case CSSValueLtr:
3185        return LTR;
3186    case CSSValueRtl:
3187        return RTL;
3188    default:
3189        break;
3190    }
3191
3192    ASSERT_NOT_REACHED();
3193    return LTR;
3194}
3195
3196template<> inline CSSPrimitiveValue::CSSPrimitiveValue(WritingMode e)
3197    : CSSValue(PrimitiveClass)
3198{
3199    m_primitiveUnitType = CSS_VALUE_ID;
3200    switch (e) {
3201    case TopToBottomWritingMode:
3202        m_value.valueID = CSSValueHorizontalTb;
3203        break;
3204    case RightToLeftWritingMode:
3205        m_value.valueID = CSSValueVerticalRl;
3206        break;
3207    case LeftToRightWritingMode:
3208        m_value.valueID = CSSValueVerticalLr;
3209        break;
3210    case BottomToTopWritingMode:
3211        m_value.valueID = CSSValueHorizontalBt;
3212        break;
3213    }
3214}
3215
3216template<> inline CSSPrimitiveValue::operator WritingMode() const
3217{
3218    ASSERT(isValueID());
3219
3220    switch (m_value.valueID) {
3221    case CSSValueHorizontalTb:
3222        return TopToBottomWritingMode;
3223    case CSSValueVerticalRl:
3224        return RightToLeftWritingMode;
3225    case CSSValueVerticalLr:
3226        return LeftToRightWritingMode;
3227    case CSSValueHorizontalBt:
3228        return BottomToTopWritingMode;
3229    default:
3230        break;
3231    }
3232
3233    ASSERT_NOT_REACHED();
3234    return TopToBottomWritingMode;
3235}
3236
3237template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextCombine e)
3238    : CSSValue(PrimitiveClass)
3239{
3240    m_primitiveUnitType = CSS_VALUE_ID;
3241    switch (e) {
3242    case TextCombineNone:
3243        m_value.valueID = CSSValueNone;
3244        break;
3245    case TextCombineHorizontal:
3246        m_value.valueID = CSSValueHorizontal;
3247        break;
3248    }
3249}
3250
3251template<> inline CSSPrimitiveValue::operator TextCombine() const
3252{
3253    ASSERT(isValueID());
3254
3255    switch (m_value.valueID) {
3256    case CSSValueNone:
3257        return TextCombineNone;
3258    case CSSValueHorizontal:
3259        return TextCombineHorizontal;
3260    default:
3261        break;
3262    }
3263
3264    ASSERT_NOT_REACHED();
3265    return TextCombineNone;
3266}
3267
3268template<> inline CSSPrimitiveValue::CSSPrimitiveValue(RubyPosition position)
3269    : CSSValue(PrimitiveClass)
3270{
3271    m_primitiveUnitType = CSS_VALUE_ID;
3272    switch (position) {
3273    case RubyPositionBefore:
3274        m_value.valueID = CSSValueBefore;
3275        break;
3276    case RubyPositionAfter:
3277        m_value.valueID = CSSValueAfter;
3278        break;
3279    }
3280}
3281
3282template<> inline CSSPrimitiveValue::operator RubyPosition() const
3283{
3284    ASSERT(isValueID());
3285
3286    switch (m_value.valueID) {
3287    case CSSValueBefore:
3288        return RubyPositionBefore;
3289    case CSSValueAfter:
3290        return RubyPositionAfter;
3291    default:
3292        break;
3293    }
3294
3295    ASSERT_NOT_REACHED();
3296    return RubyPositionBefore;
3297}
3298
3299template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextOverflow overflow)
3300    : CSSValue(PrimitiveClass)
3301{
3302    m_primitiveUnitType = CSS_VALUE_ID;
3303    switch (overflow) {
3304    case TextOverflowClip:
3305        m_value.valueID = CSSValueClip;
3306        break;
3307    case TextOverflowEllipsis:
3308        m_value.valueID = CSSValueEllipsis;
3309        break;
3310    }
3311}
3312
3313template<> inline CSSPrimitiveValue::operator TextOverflow() const
3314{
3315    ASSERT(isValueID());
3316
3317    switch (m_value.valueID) {
3318    case CSSValueClip:
3319        return TextOverflowClip;
3320    case CSSValueEllipsis:
3321        return TextOverflowEllipsis;
3322    default:
3323        break;
3324    }
3325
3326    ASSERT_NOT_REACHED();
3327    return TextOverflowClip;
3328}
3329
3330template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextEmphasisFill fill)
3331    : CSSValue(PrimitiveClass)
3332{
3333    m_primitiveUnitType = CSS_VALUE_ID;
3334    switch (fill) {
3335    case TextEmphasisFillFilled:
3336        m_value.valueID = CSSValueFilled;
3337        break;
3338    case TextEmphasisFillOpen:
3339        m_value.valueID = CSSValueOpen;
3340        break;
3341    }
3342}
3343
3344template<> inline CSSPrimitiveValue::operator TextEmphasisFill() const
3345{
3346    ASSERT(isValueID());
3347
3348    switch (m_value.valueID) {
3349    case CSSValueFilled:
3350        return TextEmphasisFillFilled;
3351    case CSSValueOpen:
3352        return TextEmphasisFillOpen;
3353    default:
3354        break;
3355    }
3356
3357    ASSERT_NOT_REACHED();
3358    return TextEmphasisFillFilled;
3359}
3360
3361template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextEmphasisMark mark)
3362    : CSSValue(PrimitiveClass)
3363{
3364    m_primitiveUnitType = CSS_VALUE_ID;
3365    switch (mark) {
3366    case TextEmphasisMarkDot:
3367        m_value.valueID = CSSValueDot;
3368        break;
3369    case TextEmphasisMarkCircle:
3370        m_value.valueID = CSSValueCircle;
3371        break;
3372    case TextEmphasisMarkDoubleCircle:
3373        m_value.valueID = CSSValueDoubleCircle;
3374        break;
3375    case TextEmphasisMarkTriangle:
3376        m_value.valueID = CSSValueTriangle;
3377        break;
3378    case TextEmphasisMarkSesame:
3379        m_value.valueID = CSSValueSesame;
3380        break;
3381    case TextEmphasisMarkNone:
3382    case TextEmphasisMarkAuto:
3383    case TextEmphasisMarkCustom:
3384        ASSERT_NOT_REACHED();
3385        m_value.valueID = CSSValueNone;
3386        break;
3387    }
3388}
3389
3390template<> inline CSSPrimitiveValue::operator TextEmphasisMark() const
3391{
3392    ASSERT(isValueID());
3393
3394    switch (m_value.valueID) {
3395    case CSSValueNone:
3396        return TextEmphasisMarkNone;
3397    case CSSValueDot:
3398        return TextEmphasisMarkDot;
3399    case CSSValueCircle:
3400        return TextEmphasisMarkCircle;
3401    case CSSValueDoubleCircle:
3402        return TextEmphasisMarkDoubleCircle;
3403    case CSSValueTriangle:
3404        return TextEmphasisMarkTriangle;
3405    case CSSValueSesame:
3406        return TextEmphasisMarkSesame;
3407    default:
3408        break;
3409    }
3410
3411    ASSERT_NOT_REACHED();
3412    return TextEmphasisMarkNone;
3413}
3414
3415template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextOrientation e)
3416    : CSSValue(PrimitiveClass)
3417{
3418    m_primitiveUnitType = CSS_VALUE_ID;
3419    switch (e) {
3420    case TextOrientationSideways:
3421        m_value.valueID = CSSValueSideways;
3422        break;
3423    case TextOrientationSidewaysRight:
3424        m_value.valueID = CSSValueSidewaysRight;
3425        break;
3426    case TextOrientationVerticalRight:
3427        m_value.valueID = CSSValueVerticalRight;
3428        break;
3429    case TextOrientationUpright:
3430        m_value.valueID = CSSValueUpright;
3431        break;
3432    }
3433}
3434
3435template<> inline CSSPrimitiveValue::operator TextOrientation() const
3436{
3437    ASSERT(isValueID());
3438
3439    switch (m_value.valueID) {
3440    case CSSValueSideways:
3441        return TextOrientationSideways;
3442    case CSSValueSidewaysRight:
3443        return TextOrientationSidewaysRight;
3444    case CSSValueVerticalRight:
3445        return TextOrientationVerticalRight;
3446    case CSSValueUpright:
3447        return TextOrientationUpright;
3448    default:
3449        break;
3450    }
3451
3452    ASSERT_NOT_REACHED();
3453    return TextOrientationVerticalRight;
3454}
3455
3456template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EPointerEvents e)
3457    : CSSValue(PrimitiveClass)
3458{
3459    m_primitiveUnitType = CSS_VALUE_ID;
3460    switch (e) {
3461    case PE_NONE:
3462        m_value.valueID = CSSValueNone;
3463        break;
3464    case PE_STROKE:
3465        m_value.valueID = CSSValueStroke;
3466        break;
3467    case PE_FILL:
3468        m_value.valueID = CSSValueFill;
3469        break;
3470    case PE_PAINTED:
3471        m_value.valueID = CSSValuePainted;
3472        break;
3473    case PE_VISIBLE:
3474        m_value.valueID = CSSValueVisible;
3475        break;
3476    case PE_VISIBLE_STROKE:
3477        m_value.valueID = CSSValueVisiblestroke;
3478        break;
3479    case PE_VISIBLE_FILL:
3480        m_value.valueID = CSSValueVisiblefill;
3481        break;
3482    case PE_VISIBLE_PAINTED:
3483        m_value.valueID = CSSValueVisiblepainted;
3484        break;
3485    case PE_AUTO:
3486        m_value.valueID = CSSValueAuto;
3487        break;
3488    case PE_ALL:
3489        m_value.valueID = CSSValueAll;
3490        break;
3491    }
3492}
3493
3494template<> inline CSSPrimitiveValue::operator EPointerEvents() const
3495{
3496    ASSERT(isValueID());
3497
3498    switch (m_value.valueID) {
3499    case CSSValueAll:
3500        return PE_ALL;
3501    case CSSValueAuto:
3502        return PE_AUTO;
3503    case CSSValueNone:
3504        return PE_NONE;
3505    case CSSValueVisiblepainted:
3506        return PE_VISIBLE_PAINTED;
3507    case CSSValueVisiblefill:
3508        return PE_VISIBLE_FILL;
3509    case CSSValueVisiblestroke:
3510        return PE_VISIBLE_STROKE;
3511    case CSSValueVisible:
3512        return PE_VISIBLE;
3513    case CSSValuePainted:
3514        return PE_PAINTED;
3515    case CSSValueFill:
3516        return PE_FILL;
3517    case CSSValueStroke:
3518        return PE_STROKE;
3519    default:
3520        break;
3521    }
3522
3523    ASSERT_NOT_REACHED();
3524    return PE_ALL;
3525}
3526
3527template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontDescription::Kerning kerning)
3528    : CSSValue(PrimitiveClass)
3529{
3530    m_primitiveUnitType = CSS_VALUE_ID;
3531    switch (kerning) {
3532    case FontDescription::AutoKerning:
3533        m_value.valueID = CSSValueAuto;
3534        return;
3535    case FontDescription::NormalKerning:
3536        m_value.valueID = CSSValueNormal;
3537        return;
3538    case FontDescription::NoneKerning:
3539        m_value.valueID = CSSValueNone;
3540        return;
3541    }
3542
3543    ASSERT_NOT_REACHED();
3544    m_value.valueID = CSSValueAuto;
3545}
3546
3547template<> inline CSSPrimitiveValue::operator FontDescription::Kerning() const
3548{
3549    ASSERT(isValueID());
3550
3551    switch (m_value.valueID) {
3552    case CSSValueAuto:
3553        return FontDescription::AutoKerning;
3554    case CSSValueNormal:
3555        return FontDescription::NormalKerning;
3556    case CSSValueNone:
3557        return FontDescription::NoneKerning;
3558    default:
3559        break;
3560    }
3561
3562    ASSERT_NOT_REACHED();
3563    return FontDescription::AutoKerning;
3564}
3565
3566template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ObjectFit fit)
3567    : CSSValue(PrimitiveClass)
3568{
3569    m_primitiveUnitType = CSS_VALUE_ID;
3570    switch (fit) {
3571    case ObjectFitFill:
3572        m_value.valueID = CSSValueFill;
3573        break;
3574    case ObjectFitContain:
3575        m_value.valueID = CSSValueContain;
3576        break;
3577    case ObjectFitCover:
3578        m_value.valueID = CSSValueCover;
3579        break;
3580    case ObjectFitNone:
3581        m_value.valueID = CSSValueNone;
3582        break;
3583    case ObjectFitScaleDown:
3584        m_value.valueID = CSSValueScaleDown;
3585        break;
3586    }
3587}
3588
3589template<> inline CSSPrimitiveValue::operator ObjectFit() const
3590{
3591    ASSERT(isValueID());
3592
3593    switch (m_value.valueID) {
3594    case CSSValueFill:
3595        return ObjectFitFill;
3596    case CSSValueContain:
3597        return ObjectFitContain;
3598    case CSSValueCover:
3599        return ObjectFitCover;
3600    case CSSValueNone:
3601        return ObjectFitNone;
3602    case CSSValueScaleDown:
3603        return ObjectFitScaleDown;
3604    default:
3605        ASSERT_NOT_REACHED();
3606        return ObjectFitFill;
3607    }
3608}
3609
3610template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontSmoothingMode smoothing)
3611    : CSSValue(PrimitiveClass)
3612{
3613    m_primitiveUnitType = CSS_VALUE_ID;
3614    switch (smoothing) {
3615    case AutoSmoothing:
3616        m_value.valueID = CSSValueAuto;
3617        return;
3618    case NoSmoothing:
3619        m_value.valueID = CSSValueNone;
3620        return;
3621    case Antialiased:
3622        m_value.valueID = CSSValueAntialiased;
3623        return;
3624    case SubpixelAntialiased:
3625        m_value.valueID = CSSValueSubpixelAntialiased;
3626        return;
3627    }
3628
3629    ASSERT_NOT_REACHED();
3630    m_value.valueID = CSSValueAuto;
3631}
3632
3633template<> inline CSSPrimitiveValue::operator FontSmoothingMode() const
3634{
3635    ASSERT(isValueID());
3636
3637    switch (m_value.valueID) {
3638    case CSSValueAuto:
3639        return AutoSmoothing;
3640    case CSSValueNone:
3641        return NoSmoothing;
3642    case CSSValueAntialiased:
3643        return Antialiased;
3644    case CSSValueSubpixelAntialiased:
3645        return SubpixelAntialiased;
3646    default:
3647        break;
3648    }
3649
3650    ASSERT_NOT_REACHED();
3651    return AutoSmoothing;
3652}
3653
3654template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontWeight weight)
3655    : CSSValue(PrimitiveClass)
3656{
3657    m_primitiveUnitType = CSS_VALUE_ID;
3658    switch (weight) {
3659    case FontWeight900:
3660        m_value.valueID = CSSValue900;
3661        return;
3662    case FontWeight800:
3663        m_value.valueID = CSSValue800;
3664        return;
3665    case FontWeight700:
3666        m_value.valueID = CSSValue700;
3667        return;
3668    case FontWeight600:
3669        m_value.valueID = CSSValue600;
3670        return;
3671    case FontWeight500:
3672        m_value.valueID = CSSValue500;
3673        return;
3674    case FontWeight400:
3675        m_value.valueID = CSSValue400;
3676        return;
3677    case FontWeight300:
3678        m_value.valueID = CSSValue300;
3679        return;
3680    case FontWeight200:
3681        m_value.valueID = CSSValue200;
3682        return;
3683    case FontWeight100:
3684        m_value.valueID = CSSValue100;
3685        return;
3686    }
3687
3688    ASSERT_NOT_REACHED();
3689    m_value.valueID = CSSValueNormal;
3690}
3691
3692template<> inline CSSPrimitiveValue::operator FontWeight() const
3693{
3694    ASSERT(isValueID());
3695
3696    switch (m_value.valueID) {
3697    case CSSValueBold:
3698        return FontWeightBold;
3699    case CSSValueNormal:
3700        return FontWeightNormal;
3701    case CSSValue900:
3702        return FontWeight900;
3703    case CSSValue800:
3704        return FontWeight800;
3705    case CSSValue700:
3706        return FontWeight700;
3707    case CSSValue600:
3708        return FontWeight600;
3709    case CSSValue500:
3710        return FontWeight500;
3711    case CSSValue400:
3712        return FontWeight400;
3713    case CSSValue300:
3714        return FontWeight300;
3715    case CSSValue200:
3716        return FontWeight200;
3717    case CSSValue100:
3718        return FontWeight100;
3719    default:
3720        break;
3721    }
3722
3723    ASSERT_NOT_REACHED();
3724    return FontWeightNormal;
3725}
3726
3727template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontItalic italic)
3728    : CSSValue(PrimitiveClass)
3729{
3730    m_primitiveUnitType = CSS_VALUE_ID;
3731    switch (italic) {
3732    case FontItalicOff:
3733        m_value.valueID = CSSValueNormal;
3734        return;
3735    case FontItalicOn:
3736        m_value.valueID = CSSValueItalic;
3737        return;
3738    }
3739
3740    ASSERT_NOT_REACHED();
3741    m_value.valueID = CSSValueNormal;
3742}
3743
3744template<> inline CSSPrimitiveValue::operator FontItalic() const
3745{
3746    ASSERT(isValueID());
3747
3748    switch (m_value.valueID) {
3749    case CSSValueOblique:
3750    // FIXME: oblique is the same as italic for the moment...
3751    case CSSValueItalic:
3752        return FontItalicOn;
3753    case CSSValueNormal:
3754        return FontItalicOff;
3755    default:
3756        break;
3757    }
3758    ASSERT_NOT_REACHED();
3759    return FontItalicOff;
3760}
3761
3762template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontSmallCaps smallCaps)
3763    : CSSValue(PrimitiveClass)
3764{
3765    m_primitiveUnitType = CSS_VALUE_ID;
3766    switch (smallCaps) {
3767    case FontSmallCapsOff:
3768        m_value.valueID = CSSValueNormal;
3769        return;
3770    case FontSmallCapsOn:
3771        m_value.valueID = CSSValueSmallCaps;
3772        return;
3773    }
3774
3775    ASSERT_NOT_REACHED();
3776    m_value.valueID = CSSValueNormal;
3777}
3778
3779template<> inline CSSPrimitiveValue::operator FontSmallCaps() const
3780{
3781    ASSERT(isValueID());
3782
3783    switch (m_value.valueID) {
3784    case CSSValueSmallCaps:
3785        return FontSmallCapsOn;
3786    case CSSValueNormal:
3787        return FontSmallCapsOff;
3788    default:
3789        break;
3790    }
3791    ASSERT_NOT_REACHED();
3792    return FontSmallCapsOff;
3793}
3794
3795template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextRenderingMode e)
3796    : CSSValue(PrimitiveClass)
3797{
3798    m_primitiveUnitType = CSS_VALUE_ID;
3799    switch (e) {
3800    case AutoTextRendering:
3801        m_value.valueID = CSSValueAuto;
3802        break;
3803    case OptimizeSpeed:
3804        m_value.valueID = CSSValueOptimizespeed;
3805        break;
3806    case OptimizeLegibility:
3807        m_value.valueID = CSSValueOptimizelegibility;
3808        break;
3809    case GeometricPrecision:
3810        m_value.valueID = CSSValueGeometricprecision;
3811        break;
3812    }
3813}
3814
3815template<> inline CSSPrimitiveValue::operator TextRenderingMode() const
3816{
3817    ASSERT(isValueID());
3818
3819    switch (m_value.valueID) {
3820    case CSSValueAuto:
3821        return AutoTextRendering;
3822    case CSSValueOptimizespeed:
3823        return OptimizeSpeed;
3824    case CSSValueOptimizelegibility:
3825        return OptimizeLegibility;
3826    case CSSValueGeometricprecision:
3827        return GeometricPrecision;
3828    default:
3829        break;
3830    }
3831
3832    ASSERT_NOT_REACHED();
3833    return AutoTextRendering;
3834}
3835
3836template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ColorSpace space)
3837    : CSSValue(PrimitiveClass)
3838{
3839    m_primitiveUnitType = CSS_VALUE_ID;
3840    switch (space) {
3841    case ColorSpaceDeviceRGB:
3842        m_value.valueID = CSSValueDefault;
3843        break;
3844    case ColorSpaceSRGB:
3845        m_value.valueID = CSSValueSrgb;
3846        break;
3847    case ColorSpaceLinearRGB:
3848        // CSS color correction does not support linearRGB yet.
3849        ASSERT_NOT_REACHED();
3850        m_value.valueID = CSSValueDefault;
3851        break;
3852    }
3853}
3854
3855template<> inline CSSPrimitiveValue::operator ColorSpace() const
3856{
3857    ASSERT(isValueID());
3858
3859    switch (m_value.valueID) {
3860    case CSSValueDefault:
3861        return ColorSpaceDeviceRGB;
3862    case CSSValueSrgb:
3863        return ColorSpaceSRGB;
3864    default:
3865        break;
3866    }
3867
3868    ASSERT_NOT_REACHED();
3869    return ColorSpaceDeviceRGB;
3870}
3871
3872template<> inline CSSPrimitiveValue::CSSPrimitiveValue(Hyphens hyphens)
3873    : CSSValue(PrimitiveClass)
3874{
3875    m_primitiveUnitType = CSS_VALUE_ID;
3876    switch (hyphens) {
3877    case HyphensNone:
3878        m_value.valueID = CSSValueNone;
3879        break;
3880    case HyphensManual:
3881        m_value.valueID = CSSValueManual;
3882        break;
3883    case HyphensAuto:
3884        m_value.valueID = CSSValueAuto;
3885        break;
3886    }
3887}
3888
3889template<> inline CSSPrimitiveValue::operator Hyphens() const
3890{
3891    ASSERT(isValueID());
3892
3893    switch (m_value.valueID) {
3894    case CSSValueNone:
3895        return HyphensNone;
3896    case CSSValueManual:
3897        return HyphensManual;
3898    case CSSValueAuto:
3899        return HyphensAuto;
3900    default:
3901        break;
3902    }
3903
3904    ASSERT_NOT_REACHED();
3905    return HyphensAuto;
3906}
3907
3908template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineSnap gridSnap)
3909    : CSSValue(PrimitiveClass)
3910{
3911    m_primitiveUnitType = CSS_VALUE_ID;
3912    switch (gridSnap) {
3913    case LineSnapNone:
3914        m_value.valueID = CSSValueNone;
3915        break;
3916    case LineSnapBaseline:
3917        m_value.valueID = CSSValueBaseline;
3918        break;
3919    case LineSnapContain:
3920        m_value.valueID = CSSValueContain;
3921        break;
3922    }
3923}
3924
3925template<> inline CSSPrimitiveValue::operator LineSnap() const
3926{
3927    ASSERT(isValueID());
3928
3929    switch (m_value.valueID) {
3930    case CSSValueNone:
3931        return LineSnapNone;
3932    case CSSValueBaseline:
3933        return LineSnapBaseline;
3934    case CSSValueContain:
3935        return LineSnapContain;
3936    default:
3937        break;
3938    }
3939
3940    ASSERT_NOT_REACHED();
3941    return LineSnapNone;
3942}
3943
3944template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineAlign lineAlign)
3945    : CSSValue(PrimitiveClass)
3946{
3947    m_primitiveUnitType = CSS_VALUE_ID;
3948    switch (lineAlign) {
3949    case LineAlignNone:
3950        m_value.valueID = CSSValueNone;
3951        break;
3952    case LineAlignEdges:
3953        m_value.valueID = CSSValueEdges;
3954        break;
3955    }
3956}
3957
3958template<> inline CSSPrimitiveValue::operator LineAlign() const
3959{
3960    ASSERT(isValueID());
3961
3962    switch (m_value.valueID) {
3963    case CSSValueNone:
3964        return LineAlignNone;
3965    case CSSValueEdges:
3966        return LineAlignEdges;
3967    default:
3968        break;
3969    }
3970
3971    ASSERT_NOT_REACHED();
3972    return LineAlignNone;
3973}
3974
3975template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ESpeak e)
3976    : CSSValue(PrimitiveClass)
3977{
3978    m_primitiveUnitType = CSS_VALUE_ID;
3979    switch (e) {
3980    case SpeakNone:
3981        m_value.valueID = CSSValueNone;
3982        break;
3983    case SpeakNormal:
3984        m_value.valueID = CSSValueNormal;
3985        break;
3986    case SpeakSpellOut:
3987        m_value.valueID = CSSValueSpellOut;
3988        break;
3989    case SpeakDigits:
3990        m_value.valueID = CSSValueDigits;
3991        break;
3992    case SpeakLiteralPunctuation:
3993        m_value.valueID = CSSValueLiteralPunctuation;
3994        break;
3995    case SpeakNoPunctuation:
3996        m_value.valueID = CSSValueNoPunctuation;
3997        break;
3998    }
3999}
4000
4001template<> inline CSSPrimitiveValue::operator Order() const
4002{
4003    ASSERT(isValueID());
4004
4005    switch (m_value.valueID) {
4006    case CSSValueLogical:
4007        return LogicalOrder;
4008    case CSSValueVisual:
4009        return VisualOrder;
4010    default:
4011        break;
4012    }
4013
4014    ASSERT_NOT_REACHED();
4015    return LogicalOrder;
4016}
4017
4018template<> inline CSSPrimitiveValue::CSSPrimitiveValue(Order e)
4019    : CSSValue(PrimitiveClass)
4020{
4021    m_primitiveUnitType = CSS_VALUE_ID;
4022    switch (e) {
4023    case LogicalOrder:
4024        m_value.valueID = CSSValueLogical;
4025        break;
4026    case VisualOrder:
4027        m_value.valueID = CSSValueVisual;
4028        break;
4029    }
4030}
4031
4032template<> inline CSSPrimitiveValue::operator ESpeak() const
4033{
4034    ASSERT(isValueID());
4035
4036    switch (m_value.valueID) {
4037    case CSSValueNone:
4038        return SpeakNone;
4039    case CSSValueNormal:
4040        return SpeakNormal;
4041    case CSSValueSpellOut:
4042        return SpeakSpellOut;
4043    case CSSValueDigits:
4044        return SpeakDigits;
4045    case CSSValueLiteralPunctuation:
4046        return SpeakLiteralPunctuation;
4047    case CSSValueNoPunctuation:
4048        return SpeakNoPunctuation;
4049    default:
4050        break;
4051    }
4052
4053    ASSERT_NOT_REACHED();
4054    return SpeakNormal;
4055}
4056
4057template<> inline CSSPrimitiveValue::CSSPrimitiveValue(BlendMode blendMode)
4058    : CSSValue(PrimitiveClass)
4059{
4060    m_primitiveUnitType = CSS_VALUE_ID;
4061    switch (blendMode) {
4062    case BlendModeNormal:
4063        m_value.valueID = CSSValueNormal;
4064        break;
4065    case BlendModeMultiply:
4066        m_value.valueID = CSSValueMultiply;
4067        break;
4068    case BlendModeScreen:
4069        m_value.valueID = CSSValueScreen;
4070        break;
4071    case BlendModeOverlay:
4072        m_value.valueID = CSSValueOverlay;
4073        break;
4074    case BlendModeDarken:
4075        m_value.valueID = CSSValueDarken;
4076        break;
4077    case BlendModeLighten:
4078        m_value.valueID = CSSValueLighten;
4079        break;
4080    case BlendModeColorDodge:
4081        m_value.valueID = CSSValueColorDodge;
4082        break;
4083    case BlendModeColorBurn:
4084        m_value.valueID = CSSValueColorBurn;
4085        break;
4086    case BlendModeHardLight:
4087        m_value.valueID = CSSValueHardLight;
4088        break;
4089    case BlendModeSoftLight:
4090        m_value.valueID = CSSValueSoftLight;
4091        break;
4092    case BlendModeDifference:
4093        m_value.valueID = CSSValueDifference;
4094        break;
4095    case BlendModeExclusion:
4096        m_value.valueID = CSSValueExclusion;
4097        break;
4098    case BlendModeHue:
4099        m_value.valueID = CSSValueHue;
4100        break;
4101    case BlendModeSaturation:
4102        m_value.valueID = CSSValueSaturation;
4103        break;
4104    case BlendModeColor:
4105        m_value.valueID = CSSValueColor;
4106        break;
4107    case BlendModeLuminosity:
4108        m_value.valueID = CSSValueLuminosity;
4109        break;
4110    }
4111}
4112
4113template<> inline CSSPrimitiveValue::operator BlendMode() const
4114{
4115    ASSERT(isValueID());
4116
4117    switch (m_value.valueID) {
4118    case CSSValueNormal:
4119        return BlendModeNormal;
4120    case CSSValueMultiply:
4121        return BlendModeMultiply;
4122    case CSSValueScreen:
4123        return BlendModeScreen;
4124    case CSSValueOverlay:
4125        return BlendModeOverlay;
4126    case CSSValueDarken:
4127        return BlendModeDarken;
4128    case CSSValueLighten:
4129        return BlendModeLighten;
4130    case CSSValueColorDodge:
4131        return BlendModeColorDodge;
4132    case CSSValueColorBurn:
4133        return BlendModeColorBurn;
4134    case CSSValueHardLight:
4135        return BlendModeHardLight;
4136    case CSSValueSoftLight:
4137        return BlendModeSoftLight;
4138    case CSSValueDifference:
4139        return BlendModeDifference;
4140    case CSSValueExclusion:
4141        return BlendModeExclusion;
4142    case CSSValueHue:
4143        return BlendModeHue;
4144    case CSSValueSaturation:
4145        return BlendModeSaturation;
4146    case CSSValueColor:
4147        return BlendModeColor;
4148    case CSSValueLuminosity:
4149        return BlendModeLuminosity;
4150    default:
4151        break;
4152    }
4153
4154    ASSERT_NOT_REACHED();
4155    return BlendModeNormal;
4156}
4157
4158template<> inline CSSPrimitiveValue::CSSPrimitiveValue(Isolation isolation)
4159    : CSSValue(PrimitiveClass)
4160{
4161    m_primitiveUnitType = CSS_VALUE_ID;
4162    switch (isolation) {
4163    case IsolationAuto:
4164        m_value.valueID = CSSValueAuto;
4165        break;
4166    case IsolationIsolate:
4167        m_value.valueID = CSSValueIsolate;
4168        break;
4169    default:
4170        ASSERT_NOT_REACHED();
4171    }
4172}
4173
4174template<> inline CSSPrimitiveValue::operator Isolation() const
4175{
4176    ASSERT(isValueID());
4177    switch (m_value.valueID) {
4178    case CSSValueAuto:
4179        return IsolationAuto;
4180    case CSSValueIsolate:
4181        return IsolationIsolate;
4182    default:
4183        break;
4184    }
4185
4186    ASSERT_NOT_REACHED();
4187    return IsolationAuto;
4188}
4189
4190template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineCap e)
4191    : CSSValue(PrimitiveClass)
4192{
4193    m_primitiveUnitType = CSS_VALUE_ID;
4194    switch (e) {
4195    case ButtCap:
4196        m_value.valueID = CSSValueButt;
4197        break;
4198    case RoundCap:
4199        m_value.valueID = CSSValueRound;
4200        break;
4201    case SquareCap:
4202        m_value.valueID = CSSValueSquare;
4203        break;
4204    }
4205}
4206
4207template<> inline CSSPrimitiveValue::operator LineCap() const
4208{
4209    ASSERT(isValueID());
4210
4211    switch (m_value.valueID) {
4212    case CSSValueButt:
4213        return ButtCap;
4214    case CSSValueRound:
4215        return RoundCap;
4216    case CSSValueSquare:
4217        return SquareCap;
4218    default:
4219        break;
4220    }
4221
4222    ASSERT_NOT_REACHED();
4223    return ButtCap;
4224}
4225
4226template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineJoin e)
4227    : CSSValue(PrimitiveClass)
4228{
4229    m_primitiveUnitType = CSS_VALUE_ID;
4230    switch (e) {
4231    case MiterJoin:
4232        m_value.valueID = CSSValueMiter;
4233        break;
4234    case RoundJoin:
4235        m_value.valueID = CSSValueRound;
4236        break;
4237    case BevelJoin:
4238        m_value.valueID = CSSValueBevel;
4239        break;
4240    }
4241}
4242
4243template<> inline CSSPrimitiveValue::operator LineJoin() const
4244{
4245    ASSERT(isValueID());
4246
4247    switch (m_value.valueID) {
4248    case CSSValueMiter:
4249        return MiterJoin;
4250    case CSSValueRound:
4251        return RoundJoin;
4252    case CSSValueBevel:
4253        return BevelJoin;
4254    default:
4255        break;
4256    }
4257
4258    ASSERT_NOT_REACHED();
4259    return MiterJoin;
4260}
4261
4262template<> inline CSSPrimitiveValue::CSSPrimitiveValue(WindRule e)
4263    : CSSValue(PrimitiveClass)
4264{
4265    m_primitiveUnitType = CSS_VALUE_ID;
4266    switch (e) {
4267    case RULE_NONZERO:
4268        m_value.valueID = CSSValueNonzero;
4269        break;
4270    case RULE_EVENODD:
4271        m_value.valueID = CSSValueEvenodd;
4272        break;
4273    }
4274}
4275
4276template<> inline CSSPrimitiveValue::operator WindRule() const
4277{
4278    ASSERT(isValueID());
4279
4280    switch (m_value.valueID) {
4281    case CSSValueNonzero:
4282        return RULE_NONZERO;
4283    case CSSValueEvenodd:
4284        return RULE_EVENODD;
4285    default:
4286        break;
4287    }
4288
4289    ASSERT_NOT_REACHED();
4290    return RULE_NONZERO;
4291}
4292
4293
4294template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EAlignmentBaseline e)
4295    : CSSValue(PrimitiveClass)
4296{
4297    m_primitiveUnitType = CSS_VALUE_ID;
4298    switch (e) {
4299    case AB_AUTO:
4300        m_value.valueID = CSSValueAuto;
4301        break;
4302    case AB_BASELINE:
4303        m_value.valueID = CSSValueBaseline;
4304        break;
4305    case AB_BEFORE_EDGE:
4306        m_value.valueID = CSSValueBeforeEdge;
4307        break;
4308    case AB_TEXT_BEFORE_EDGE:
4309        m_value.valueID = CSSValueTextBeforeEdge;
4310        break;
4311    case AB_MIDDLE:
4312        m_value.valueID = CSSValueMiddle;
4313        break;
4314    case AB_CENTRAL:
4315        m_value.valueID = CSSValueCentral;
4316        break;
4317    case AB_AFTER_EDGE:
4318        m_value.valueID = CSSValueAfterEdge;
4319        break;
4320    case AB_TEXT_AFTER_EDGE:
4321        m_value.valueID = CSSValueTextAfterEdge;
4322        break;
4323    case AB_IDEOGRAPHIC:
4324        m_value.valueID = CSSValueIdeographic;
4325        break;
4326    case AB_ALPHABETIC:
4327        m_value.valueID = CSSValueAlphabetic;
4328        break;
4329    case AB_HANGING:
4330        m_value.valueID = CSSValueHanging;
4331        break;
4332    case AB_MATHEMATICAL:
4333        m_value.valueID = CSSValueMathematical;
4334        break;
4335    }
4336}
4337
4338template<> inline CSSPrimitiveValue::operator EAlignmentBaseline() const
4339{
4340    ASSERT(isValueID());
4341
4342    switch (m_value.valueID) {
4343    case CSSValueAuto:
4344        return AB_AUTO;
4345    case CSSValueBaseline:
4346        return AB_BASELINE;
4347    case CSSValueBeforeEdge:
4348        return AB_BEFORE_EDGE;
4349    case CSSValueTextBeforeEdge:
4350        return AB_TEXT_BEFORE_EDGE;
4351    case CSSValueMiddle:
4352        return AB_MIDDLE;
4353    case CSSValueCentral:
4354        return AB_CENTRAL;
4355    case CSSValueAfterEdge:
4356        return AB_AFTER_EDGE;
4357    case CSSValueTextAfterEdge:
4358        return AB_TEXT_AFTER_EDGE;
4359    case CSSValueIdeographic:
4360        return AB_IDEOGRAPHIC;
4361    case CSSValueAlphabetic:
4362        return AB_ALPHABETIC;
4363    case CSSValueHanging:
4364        return AB_HANGING;
4365    case CSSValueMathematical:
4366        return AB_MATHEMATICAL;
4367    default:
4368        break;
4369    }
4370
4371    ASSERT_NOT_REACHED();
4372    return AB_AUTO;
4373}
4374
4375template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBorderCollapse e)
4376    : CSSValue(PrimitiveClass)
4377{
4378    m_primitiveUnitType = CSS_VALUE_ID;
4379    switch (e) {
4380    case BSEPARATE:
4381        m_value.valueID = CSSValueSeparate;
4382        break;
4383    case BCOLLAPSE:
4384        m_value.valueID = CSSValueCollapse;
4385        break;
4386    }
4387}
4388
4389template<> inline CSSPrimitiveValue::operator EBorderCollapse() const
4390{
4391    ASSERT(isValueID());
4392
4393    switch (m_value.valueID) {
4394    case CSSValueSeparate:
4395        return BSEPARATE;
4396    case CSSValueCollapse:
4397        return BCOLLAPSE;
4398    default:
4399        break;
4400    }
4401
4402    ASSERT_NOT_REACHED();
4403    return BSEPARATE;
4404}
4405
4406template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBorderFit e)
4407    : CSSValue(PrimitiveClass)
4408{
4409    m_primitiveUnitType = CSS_VALUE_ID;
4410    switch (e) {
4411    case BorderFitBorder:
4412        m_value.valueID = CSSValueBorder;
4413        break;
4414    case BorderFitLines:
4415        m_value.valueID = CSSValueLines;
4416        break;
4417    }
4418}
4419
4420template<> inline CSSPrimitiveValue::operator EBorderFit() const
4421{
4422    ASSERT(isValueID());
4423
4424    switch (m_value.valueID) {
4425    case CSSValueBorder:
4426        return BorderFitBorder;
4427    case CSSValueLines:
4428        return BorderFitLines;
4429    default:
4430        break;
4431    }
4432
4433    ASSERT_NOT_REACHED();
4434    return BorderFitLines;
4435}
4436
4437template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EImageRendering e)
4438    : CSSValue(PrimitiveClass)
4439{
4440    m_primitiveUnitType = CSS_VALUE_ID;
4441    switch (e) {
4442    case ImageRenderingAuto:
4443        m_value.valueID = CSSValueAuto;
4444        break;
4445    case ImageRenderingCrispEdges:
4446        m_value.valueID = CSSValueWebkitCrispEdges;
4447        break;
4448    case ImageRenderingOptimizeSpeed:
4449        m_value.valueID = CSSValueOptimizespeed;
4450        break;
4451    case ImageRenderingOptimizeQuality:
4452        m_value.valueID = CSSValueOptimizequality;
4453        break;
4454    }
4455}
4456
4457template<> inline CSSPrimitiveValue::operator EImageRendering() const
4458{
4459    ASSERT(isValueID());
4460
4461    switch (m_value.valueID) {
4462    case CSSValueAuto:
4463        return ImageRenderingAuto;
4464    case CSSValueWebkitOptimizeContrast:
4465    case CSSValueWebkitCrispEdges:
4466        return ImageRenderingCrispEdges;
4467    case CSSValueOptimizespeed:
4468        return ImageRenderingOptimizeSpeed;
4469    case CSSValueOptimizequality:
4470        return ImageRenderingOptimizeQuality;
4471    default:
4472        break;
4473    }
4474
4475    ASSERT_NOT_REACHED();
4476    return ImageRenderingAuto;
4477}
4478
4479template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETransformStyle3D e)
4480    : CSSValue(PrimitiveClass)
4481{
4482    m_primitiveUnitType = CSS_VALUE_ID;
4483    switch (e) {
4484    case TransformStyle3DFlat:
4485        m_value.valueID = CSSValueFlat;
4486        break;
4487    case TransformStyle3DPreserve3D:
4488        m_value.valueID = CSSValuePreserve3d;
4489        break;
4490    }
4491}
4492
4493template<> inline CSSPrimitiveValue::operator ETransformStyle3D() const
4494{
4495    ASSERT(isValueID());
4496
4497    switch (m_value.valueID) {
4498    case CSSValueFlat:
4499        return TransformStyle3DFlat;
4500    case CSSValuePreserve3d:
4501        return TransformStyle3DPreserve3D;
4502    default:
4503        break;
4504    }
4505
4506    ASSERT_NOT_REACHED();
4507    return TransformStyle3DFlat;
4508}
4509
4510template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ColumnAxis e)
4511    : CSSValue(PrimitiveClass)
4512{
4513    m_primitiveUnitType = CSS_VALUE_ID;
4514    switch (e) {
4515    case HorizontalColumnAxis:
4516        m_value.valueID = CSSValueHorizontal;
4517        break;
4518    case VerticalColumnAxis:
4519        m_value.valueID = CSSValueVertical;
4520        break;
4521    case AutoColumnAxis:
4522        m_value.valueID = CSSValueAuto;
4523        break;
4524    }
4525}
4526
4527template<> inline CSSPrimitiveValue::operator ColumnAxis() const
4528{
4529    ASSERT(isValueID());
4530
4531    switch (m_value.valueID) {
4532    case CSSValueHorizontal:
4533        return HorizontalColumnAxis;
4534    case CSSValueVertical:
4535        return VerticalColumnAxis;
4536    case CSSValueAuto:
4537        return AutoColumnAxis;
4538    default:
4539        break;
4540    }
4541
4542    ASSERT_NOT_REACHED();
4543    return AutoColumnAxis;
4544}
4545
4546template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ColumnProgression e)
4547    : CSSValue(PrimitiveClass)
4548{
4549    m_primitiveUnitType = CSS_VALUE_ID;
4550    switch (e) {
4551    case NormalColumnProgression:
4552        m_value.valueID = CSSValueNormal;
4553        break;
4554    case ReverseColumnProgression:
4555        m_value.valueID = CSSValueReverse;
4556        break;
4557    }
4558}
4559
4560template<> inline CSSPrimitiveValue::operator ColumnProgression() const
4561{
4562    ASSERT(isValueID());
4563
4564    switch (m_value.valueID) {
4565    case CSSValueNormal:
4566        return NormalColumnProgression;
4567    case CSSValueReverse:
4568        return ReverseColumnProgression;
4569    default:
4570        break;
4571    }
4572
4573    ASSERT_NOT_REACHED();
4574    return NormalColumnProgression;
4575}
4576
4577enum LengthConversion {
4578    AnyConversion = ~0,
4579    FixedIntegerConversion = 1 << 0,
4580    FixedFloatConversion = 1 << 1,
4581    AutoConversion = 1 << 2,
4582    PercentConversion = 1 << 3,
4583    FractionConversion = 1 << 4,
4584    CalculatedConversion = 1 << 5
4585};
4586
4587template<int supported> Length CSSPrimitiveValue::convertToLength(const CSSToLengthConversionData& conversionData) const
4588{
4589    if ((supported & (FixedIntegerConversion | FixedFloatConversion)) && isFontRelativeLength() && (!conversionData.style() || !conversionData.rootStyle()))
4590        return Length(Undefined);
4591    if ((supported & FixedIntegerConversion) && isLength())
4592        return computeLength<Length>(conversionData);
4593    if ((supported & FixedFloatConversion) && isLength())
4594        return Length(computeLength<double>(conversionData), Fixed);
4595    if ((supported & PercentConversion) && isPercentage())
4596        return Length(getDoubleValue(), Percent);
4597    if ((supported & FractionConversion) && isNumber())
4598        return Length(getDoubleValue() * 100.0, Percent);
4599    if ((supported & AutoConversion) && getValueID() == CSSValueAuto)
4600        return Length(Auto);
4601    if ((supported & CalculatedConversion) && isCalculated())
4602        return Length(cssCalcValue()->createCalculationValue(conversionData));
4603    return Length(Undefined);
4604}
4605
4606template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBufferedRendering e)
4607    : CSSValue(PrimitiveClass)
4608{
4609    m_primitiveUnitType = CSS_VALUE_ID;
4610    switch (e) {
4611    case BR_AUTO:
4612        m_value.valueID = CSSValueAuto;
4613        break;
4614    case BR_DYNAMIC:
4615        m_value.valueID = CSSValueDynamic;
4616        break;
4617    case BR_STATIC:
4618        m_value.valueID = CSSValueStatic;
4619        break;
4620    }
4621}
4622
4623template<> inline CSSPrimitiveValue::operator EBufferedRendering() const
4624{
4625    ASSERT(isValueID());
4626
4627    switch (m_value.valueID) {
4628    case CSSValueAuto:
4629        return BR_AUTO;
4630    case CSSValueDynamic:
4631        return BR_DYNAMIC;
4632    case CSSValueStatic:
4633        return BR_STATIC;
4634    default:
4635        break;
4636    }
4637
4638    ASSERT_NOT_REACHED();
4639    return BR_AUTO;
4640}
4641
4642template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EColorInterpolation e)
4643    : CSSValue(PrimitiveClass)
4644{
4645    m_primitiveUnitType = CSS_VALUE_ID;
4646    switch (e) {
4647    case CI_AUTO:
4648        m_value.valueID = CSSValueAuto;
4649        break;
4650    case CI_SRGB:
4651        m_value.valueID = CSSValueSrgb;
4652        break;
4653    case CI_LINEARRGB:
4654        m_value.valueID = CSSValueLinearrgb;
4655        break;
4656    }
4657}
4658
4659template<> inline CSSPrimitiveValue::operator EColorInterpolation() const
4660{
4661    ASSERT(isValueID());
4662
4663    switch (m_value.valueID) {
4664    case CSSValueSrgb:
4665        return CI_SRGB;
4666    case CSSValueLinearrgb:
4667        return CI_LINEARRGB;
4668    case CSSValueAuto:
4669        return CI_AUTO;
4670    default:
4671        break;
4672    }
4673
4674    ASSERT_NOT_REACHED();
4675    return CI_AUTO;
4676}
4677
4678template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EColorRendering e)
4679    : CSSValue(PrimitiveClass)
4680{
4681    m_primitiveUnitType = CSS_VALUE_ID;
4682    switch (e) {
4683    case CR_AUTO:
4684        m_value.valueID = CSSValueAuto;
4685        break;
4686    case CR_OPTIMIZESPEED:
4687        m_value.valueID = CSSValueOptimizespeed;
4688        break;
4689    case CR_OPTIMIZEQUALITY:
4690        m_value.valueID = CSSValueOptimizequality;
4691        break;
4692    }
4693}
4694
4695template<> inline CSSPrimitiveValue::operator EColorRendering() const
4696{
4697    ASSERT(isValueID());
4698
4699    switch (m_value.valueID) {
4700    case CSSValueOptimizespeed:
4701        return CR_OPTIMIZESPEED;
4702    case CSSValueOptimizequality:
4703        return CR_OPTIMIZEQUALITY;
4704    case CSSValueAuto:
4705        return CR_AUTO;
4706    default:
4707        break;
4708    }
4709
4710    ASSERT_NOT_REACHED();
4711    return CR_AUTO;
4712}
4713
4714template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EDominantBaseline e)
4715    : CSSValue(PrimitiveClass)
4716{
4717    m_primitiveUnitType = CSS_VALUE_ID;
4718    switch (e) {
4719    case DB_AUTO:
4720        m_value.valueID = CSSValueAuto;
4721        break;
4722    case DB_USE_SCRIPT:
4723        m_value.valueID = CSSValueUseScript;
4724        break;
4725    case DB_NO_CHANGE:
4726        m_value.valueID = CSSValueNoChange;
4727        break;
4728    case DB_RESET_SIZE:
4729        m_value.valueID = CSSValueResetSize;
4730        break;
4731    case DB_CENTRAL:
4732        m_value.valueID = CSSValueCentral;
4733        break;
4734    case DB_MIDDLE:
4735        m_value.valueID = CSSValueMiddle;
4736        break;
4737    case DB_TEXT_BEFORE_EDGE:
4738        m_value.valueID = CSSValueTextBeforeEdge;
4739        break;
4740    case DB_TEXT_AFTER_EDGE:
4741        m_value.valueID = CSSValueTextAfterEdge;
4742        break;
4743    case DB_IDEOGRAPHIC:
4744        m_value.valueID = CSSValueIdeographic;
4745        break;
4746    case DB_ALPHABETIC:
4747        m_value.valueID = CSSValueAlphabetic;
4748        break;
4749    case DB_HANGING:
4750        m_value.valueID = CSSValueHanging;
4751        break;
4752    case DB_MATHEMATICAL:
4753        m_value.valueID = CSSValueMathematical;
4754        break;
4755    }
4756}
4757
4758template<> inline CSSPrimitiveValue::operator EDominantBaseline() const
4759{
4760    ASSERT(isValueID());
4761
4762    switch (m_value.valueID) {
4763    case CSSValueAuto:
4764        return DB_AUTO;
4765    case CSSValueUseScript:
4766        return DB_USE_SCRIPT;
4767    case CSSValueNoChange:
4768        return DB_NO_CHANGE;
4769    case CSSValueResetSize:
4770        return DB_RESET_SIZE;
4771    case CSSValueIdeographic:
4772        return DB_IDEOGRAPHIC;
4773    case CSSValueAlphabetic:
4774        return DB_ALPHABETIC;
4775    case CSSValueHanging:
4776        return DB_HANGING;
4777    case CSSValueMathematical:
4778        return DB_MATHEMATICAL;
4779    case CSSValueCentral:
4780        return DB_CENTRAL;
4781    case CSSValueMiddle:
4782        return DB_MIDDLE;
4783    case CSSValueTextAfterEdge:
4784        return DB_TEXT_AFTER_EDGE;
4785    case CSSValueTextBeforeEdge:
4786        return DB_TEXT_BEFORE_EDGE;
4787    default:
4788        break;
4789    }
4790
4791    ASSERT_NOT_REACHED();
4792    return DB_AUTO;
4793}
4794
4795template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EShapeRendering e)
4796    : CSSValue(PrimitiveClass)
4797{
4798    m_primitiveUnitType = CSS_VALUE_ID;
4799    switch (e) {
4800    case SR_AUTO:
4801        m_value.valueID = CSSValueAuto;
4802        break;
4803    case SR_OPTIMIZESPEED:
4804        m_value.valueID = CSSValueOptimizespeed;
4805        break;
4806    case SR_CRISPEDGES:
4807        m_value.valueID = CSSValueCrispedges;
4808        break;
4809    case SR_GEOMETRICPRECISION:
4810        m_value.valueID = CSSValueGeometricprecision;
4811        break;
4812    }
4813}
4814
4815template<> inline CSSPrimitiveValue::operator EShapeRendering() const
4816{
4817    ASSERT(isValueID());
4818
4819    switch (m_value.valueID) {
4820    case CSSValueAuto:
4821        return SR_AUTO;
4822    case CSSValueOptimizespeed:
4823        return SR_OPTIMIZESPEED;
4824    case CSSValueCrispedges:
4825        return SR_CRISPEDGES;
4826    case CSSValueGeometricprecision:
4827        return SR_GEOMETRICPRECISION;
4828    default:
4829        break;
4830    }
4831
4832    ASSERT_NOT_REACHED();
4833    return SR_AUTO;
4834}
4835
4836template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETextAnchor e)
4837    : CSSValue(PrimitiveClass)
4838{
4839    m_primitiveUnitType = CSS_VALUE_ID;
4840    switch (e) {
4841    case TA_START:
4842        m_value.valueID = CSSValueStart;
4843        break;
4844    case TA_MIDDLE:
4845        m_value.valueID = CSSValueMiddle;
4846        break;
4847    case TA_END:
4848        m_value.valueID = CSSValueEnd;
4849        break;
4850    }
4851}
4852
4853template<> inline CSSPrimitiveValue::operator ETextAnchor() const
4854{
4855    ASSERT(isValueID());
4856
4857    switch (m_value.valueID) {
4858    case CSSValueStart:
4859        return TA_START;
4860    case CSSValueMiddle:
4861        return TA_MIDDLE;
4862    case CSSValueEnd:
4863        return TA_END;
4864    default:
4865        break;
4866    }
4867
4868    ASSERT_NOT_REACHED();
4869    return TA_START;
4870}
4871
4872template<> inline CSSPrimitiveValue::CSSPrimitiveValue(SVGWritingMode e)
4873    : CSSValue(PrimitiveClass)
4874{
4875    m_primitiveUnitType = CSS_VALUE_ID;
4876    switch (e) {
4877    case WM_LRTB:
4878        m_value.valueID = CSSValueLrTb;
4879        break;
4880    case WM_LR:
4881        m_value.valueID = CSSValueLr;
4882        break;
4883    case WM_RLTB:
4884        m_value.valueID = CSSValueRlTb;
4885        break;
4886    case WM_RL:
4887        m_value.valueID = CSSValueRl;
4888        break;
4889    case WM_TBRL:
4890        m_value.valueID = CSSValueTbRl;
4891        break;
4892    case WM_TB:
4893        m_value.valueID = CSSValueTb;
4894        break;
4895    }
4896}
4897
4898template<> inline CSSPrimitiveValue::operator SVGWritingMode() const
4899{
4900    ASSERT(isValueID());
4901
4902    switch (m_value.valueID) {
4903    case CSSValueLrTb:
4904        return WM_LRTB;
4905    case CSSValueLr:
4906        return WM_LR;
4907    case CSSValueRlTb:
4908        return WM_RLTB;
4909    case CSSValueRl:
4910        return WM_RL;
4911    case CSSValueTbRl:
4912        return WM_TBRL;
4913    case CSSValueTb:
4914        return WM_TB;
4915    default:
4916        break;
4917    }
4918
4919    ASSERT_NOT_REACHED();
4920    return WM_LRTB;
4921}
4922
4923template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EVectorEffect e)
4924    : CSSValue(PrimitiveClass)
4925{
4926    m_primitiveUnitType = CSS_VALUE_ID;
4927    switch (e) {
4928    case VE_NONE:
4929        m_value.valueID = CSSValueNone;
4930        break;
4931    case VE_NON_SCALING_STROKE:
4932        m_value.valueID = CSSValueNonScalingStroke;
4933        break;
4934    }
4935}
4936
4937template<> inline CSSPrimitiveValue::operator EVectorEffect() const
4938{
4939    ASSERT(isValueID());
4940
4941    switch (m_value.valueID) {
4942    case CSSValueNone:
4943        return VE_NONE;
4944    case CSSValueNonScalingStroke:
4945        return VE_NON_SCALING_STROKE;
4946    default:
4947        break;
4948    }
4949
4950    ASSERT_NOT_REACHED();
4951    return VE_NONE;
4952}
4953
4954template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EMaskType e)
4955    : CSSValue(PrimitiveClass)
4956{
4957    m_primitiveUnitType = CSS_VALUE_ID;
4958    switch (e) {
4959    case MT_LUMINANCE:
4960        m_value.valueID = CSSValueLuminance;
4961        break;
4962    case MT_ALPHA:
4963        m_value.valueID = CSSValueAlpha;
4964        break;
4965    }
4966}
4967
4968template<> inline CSSPrimitiveValue::operator EMaskType() const
4969{
4970    ASSERT(isValueID());
4971
4972    switch (m_value.valueID) {
4973    case CSSValueLuminance:
4974        return MT_LUMINANCE;
4975    case CSSValueAlpha:
4976        return MT_ALPHA;
4977    default:
4978        break;
4979    }
4980
4981    ASSERT_NOT_REACHED();
4982    return MT_LUMINANCE;
4983}
4984
4985#if ENABLE(CSS_IMAGE_ORIENTATION)
4986
4987template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ImageOrientationEnum e)
4988    : CSSValue(PrimitiveClass)
4989{
4990    m_primitiveUnitType = CSS_DEG;
4991    switch (e) {
4992    case OriginTopLeft:
4993        m_value.num = 0;
4994        break;
4995    case OriginRightTop:
4996        m_value.num = 90;
4997        break;
4998    case OriginBottomRight:
4999        m_value.num = 180;
5000        break;
5001    case OriginLeftBottom:
5002        m_value.num = 270;
5003        break;
5004    case OriginTopRight:
5005    case OriginLeftTop:
5006    case OriginBottomLeft:
5007    case OriginRightBottom:
5008        ASSERT_NOT_REACHED();
5009    }
5010}
5011
5012template<> inline CSSPrimitiveValue::operator ImageOrientationEnum() const
5013{
5014    ASSERT(isAngle());
5015    double quarters = 4 * getDoubleValue(CSS_TURN);
5016    int orientation = 3 & static_cast<int>(quarters < 0 ? floor(quarters) : ceil(quarters));
5017    switch (orientation) {
5018    case 0:
5019        return OriginTopLeft;
5020    case 1:
5021        return OriginRightTop;
5022    case 2:
5023        return OriginBottomRight;
5024    case 3:
5025        return OriginLeftBottom;
5026    }
5027
5028    ASSERT_NOT_REACHED();
5029    return OriginTopLeft;
5030}
5031
5032#endif // ENABLE(CSS_IMAGE_ORIENTATION)
5033
5034template<> inline CSSPrimitiveValue::CSSPrimitiveValue(CSSBoxType cssBox)
5035    : CSSValue(PrimitiveClass)
5036{
5037    m_primitiveUnitType = CSS_VALUE_ID;
5038    switch (cssBox) {
5039    case MarginBox:
5040        m_value.valueID = CSSValueMarginBox;
5041        break;
5042    case BorderBox:
5043        m_value.valueID = CSSValueBorderBox;
5044        break;
5045    case PaddingBox:
5046        m_value.valueID = CSSValuePaddingBox;
5047        break;
5048    case ContentBox:
5049        m_value.valueID = CSSValueContentBox;
5050        break;
5051    case Fill:
5052        m_value.valueID = CSSValueFill;
5053        break;
5054    case Stroke:
5055        m_value.valueID = CSSValueStroke;
5056        break;
5057    case ViewBox:
5058        m_value.valueID = CSSValueViewBox;
5059        break;
5060    case BoxMissing:
5061        ASSERT_NOT_REACHED();
5062        m_value.valueID = CSSValueNone;
5063        break;
5064    }
5065}
5066
5067template<> inline CSSPrimitiveValue::operator CSSBoxType() const
5068{
5069    switch (getValueID()) {
5070    case CSSValueMarginBox:
5071        return MarginBox;
5072    case CSSValueBorderBox:
5073        return BorderBox;
5074    case CSSValuePaddingBox:
5075        return PaddingBox;
5076    case CSSValueContentBox:
5077        return ContentBox;
5078    // The following are used in an SVG context.
5079    case CSSValueFill:
5080        return Fill;
5081    case CSSValueStroke:
5082        return Stroke;
5083    case CSSValueViewBox:
5084        return ViewBox;
5085    default:
5086        break;
5087    }
5088    ASSERT_NOT_REACHED();
5089    return BoxMissing;
5090}
5091
5092template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EJustifySelf justifySelf)
5093    : CSSValue(PrimitiveClass)
5094{
5095    m_primitiveUnitType = CSS_VALUE_ID;
5096    switch (justifySelf) {
5097    case JustifySelfAuto:
5098        m_value.valueID = CSSValueAuto;
5099        break;
5100    case JustifySelfStretch:
5101        m_value.valueID = CSSValueStretch;
5102        break;
5103    case JustifySelfBaseline:
5104        m_value.valueID = CSSValueBaseline;
5105        break;
5106    case JustifySelfCenter:
5107        m_value.valueID = CSSValueCenter;
5108        break;
5109    case JustifySelfStart:
5110        m_value.valueID = CSSValueStart;
5111        break;
5112    case JustifySelfEnd:
5113        m_value.valueID = CSSValueEnd;
5114        break;
5115    case JustifySelfSelfStart:
5116        m_value.valueID = CSSValueSelfStart;
5117        break;
5118    case JustifySelfSelfEnd:
5119        m_value.valueID = CSSValueSelfEnd;
5120        break;
5121    case JustifySelfFlexStart:
5122        m_value.valueID = CSSValueFlexStart;
5123        break;
5124    case JustifySelfFlexEnd:
5125        m_value.valueID = CSSValueFlexEnd;
5126        break;
5127    case JustifySelfLeft:
5128        m_value.valueID = CSSValueLeft;
5129        break;
5130    case JustifySelfRight:
5131        m_value.valueID = CSSValueRight;
5132        break;
5133    default:
5134        m_value.valueID = CSSValueAuto;
5135        break;
5136    }
5137}
5138
5139template<> inline CSSPrimitiveValue::operator EJustifySelf() const
5140{
5141    switch (m_value.valueID) {
5142    case CSSValueAuto:
5143        return JustifySelfAuto;
5144    case CSSValueStretch:
5145        return JustifySelfStretch;
5146    case CSSValueBaseline:
5147        return JustifySelfBaseline;
5148    case CSSValueCenter:
5149        return JustifySelfCenter;
5150    case CSSValueStart:
5151        return JustifySelfStart;
5152    case CSSValueEnd:
5153        return JustifySelfEnd;
5154    case CSSValueSelfStart:
5155        return JustifySelfSelfStart;
5156    case CSSValueSelfEnd:
5157        return JustifySelfSelfEnd;
5158    case CSSValueFlexStart:
5159        return JustifySelfFlexStart;
5160    case CSSValueFlexEnd:
5161        return JustifySelfFlexEnd;
5162    case CSSValueLeft:
5163        return JustifySelfLeft;
5164    case CSSValueRight:
5165        return JustifySelfRight;
5166    default:
5167        break;
5168    }
5169    ASSERT_NOT_REACHED();
5170    return JustifySelfAuto;
5171}
5172
5173template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EJustifySelfOverflowAlignment overflowAlignment)
5174    : CSSValue(PrimitiveClass)
5175{
5176    m_primitiveUnitType = CSS_VALUE_ID;
5177    switch (overflowAlignment) {
5178    case JustifySelfOverflowAlignmentDefault:
5179        m_value.valueID = CSSValueDefault;
5180        break;
5181    case JustifySelfOverflowAlignmentTrue:
5182        m_value.valueID = CSSValueTrue;
5183        break;
5184    case JustifySelfOverflowAlignmentSafe:
5185        m_value.valueID = CSSValueSafe;
5186        break;
5187    }
5188}
5189
5190template<> inline CSSPrimitiveValue::operator EJustifySelfOverflowAlignment() const
5191{
5192    switch (m_value.valueID) {
5193    case CSSValueTrue:
5194        return JustifySelfOverflowAlignmentTrue;
5195    case CSSValueSafe:
5196        return JustifySelfOverflowAlignmentSafe;
5197    default:
5198        break;
5199    }
5200    ASSERT_NOT_REACHED();
5201    return JustifySelfOverflowAlignmentTrue;
5202}
5203
5204}
5205
5206#endif
5207