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