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