source: webkit/trunk/Source/WebCore/css/CSSPrimitiveValueMappings.h

Last change on this file was 295425, checked in by [email protected], 3 years ago

convertingToLengthRequiresNonNullStyle needs to consider calc values
​https://bugs.webkit.org/show_bug.cgi?id=241452

Reviewed by Antti Koivisto.

  • LayoutTests/fast/css/matrix-translate-calc-units.html: Added.
  • Source/WebCore/css/CSSPrimitiveValueMappings.h:

(WebCore::CSSPrimitiveValue::convertingToLengthRequiresNonNullStyle const):
(WebCore::CSSPrimitiveValue::convertToLength const):

  • Source/WebCore/css/TransformFunctions.cpp:
  • Source/WebCore/css/calc/CSSCalcExpressionNode.h:
  • Source/WebCore/css/calc/CSSCalcInvertNode.h:
  • Source/WebCore/css/calc/CSSCalcNegateNode.h:
  • Source/WebCore/css/calc/CSSCalcOperationNode.cpp:

(WebCore::CSSCalcOperationNode::convertingToLengthRequiresNonNullStyle const):

  • Source/WebCore/css/calc/CSSCalcOperationNode.h:
  • Source/WebCore/css/calc/CSSCalcPrimitiveValueNode.cpp:

(WebCore::CSSCalcPrimitiveValueNode::convertingToLengthRequiresNonNullStyle const):

  • Source/WebCore/css/calc/CSSCalcPrimitiveValueNode.h:
  • Source/WebCore/css/calc/CSSCalcValue.cpp:

(WebCore::CSSCalcValue::convertingToLengthRequiresNonNullStyle const):

  • Source/WebCore/css/calc/CSSCalcValue.h:

Canonical link: ​https://commits.webkit.org/251431@main
  • Property svn:eol-style set to native
File size: 144.3 KB
Line 
1/*
2 * Copyright (C) 2007 Alexey Proskuryakov <[email protected]>.
3 * Copyright (C) 2008-2020 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 <[email protected]>
6 * Copyright (C) Research In Motion Limited 2010. All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 *
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 * notice, this list of conditions and the following disclaimer in the
16 * documentation and/or other materials provided with the distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
19 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
23 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 */
29
30#pragma once
31
32#include "ApplePayButtonSystemImage.h"
33#include "CSSCalcValue.h"
34#include "CSSFontFamily.h"
35#include "CSSPrimitiveValue.h"
36#include "CSSToLengthConversionData.h"
37#include "CSSValueKeywords.h"
38#include "GraphicsTypes.h"
39#include "Length.h"
40#include "LineClampValue.h"
41#include "RenderStyleConstants.h"
42#include "SVGRenderStyleDefs.h"
43#include "ScrollTypes.h"
44#include "TextFlags.h"
45#include "ThemeTypes.h"
46#include "TouchAction.h"
47#include "UnicodeBidi.h"
48#include "WritingMode.h"
49#include <wtf/MathExtras.h>
50#include <wtf/OptionSet.h>
51
52namespace WebCore {
53
54template<> inline CSSPrimitiveValue::CSSPrimitiveValue(short i)
55 : CSSValue(PrimitiveClass)
56{
57 setPrimitiveUnitType(CSSUnitType::CSS_NUMBER);
58 m_value.num = static_cast<double>(i);
59}
60
61template<> inline CSSPrimitiveValue::operator short() const
62{
63 if (primitiveType() == CSSUnitType::CSS_NUMBER || primitiveType() == CSSUnitType::CSS_INTEGER)
64 return clampTo<short>(m_value.num);
65
66 ASSERT_NOT_REACHED();
67 return 0;
68}
69
70template<> inline CSSPrimitiveValue::CSSPrimitiveValue(unsigned short i)
71 : CSSValue(PrimitiveClass)
72{
73 setPrimitiveUnitType(CSSUnitType::CSS_NUMBER);
74 m_value.num = static_cast<double>(i);
75}
76
77template<> inline CSSPrimitiveValue::operator unsigned short() const
78{
79 if (primitiveType() == CSSUnitType::CSS_NUMBER || primitiveType() == CSSUnitType::CSS_INTEGER)
80 return value<unsigned short>();
81
82 ASSERT_NOT_REACHED();
83 return 0;
84}
85
86template<> inline CSSPrimitiveValue::operator int() const
87{
88 if (primitiveType() == CSSUnitType::CSS_NUMBER || primitiveType() == CSSUnitType::CSS_INTEGER)
89 return value<int>();
90
91 ASSERT_NOT_REACHED();
92 return 0;
93}
94
95template<> inline CSSPrimitiveValue::operator unsigned() const
96{
97 if (primitiveType() == CSSUnitType::CSS_NUMBER || primitiveType() == CSSUnitType::CSS_INTEGER)
98 return value<unsigned>();
99
100 ASSERT_NOT_REACHED();
101 return 0;
102}
103
104
105template<> inline CSSPrimitiveValue::CSSPrimitiveValue(float i)
106 : CSSValue(PrimitiveClass)
107{
108 setPrimitiveUnitType(CSSUnitType::CSS_NUMBER);
109 m_value.num = static_cast<double>(i);
110}
111
112template<> inline CSSPrimitiveValue::operator float() const
113{
114 if (primitiveType() == CSSUnitType::CSS_NUMBER || primitiveType() == CSSUnitType::CSS_INTEGER)
115 return value<float>();
116
117 ASSERT_NOT_REACHED();
118 return 0.0f;
119}
120
121template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineClampValue i)
122 : CSSValue(PrimitiveClass)
123{
124 setPrimitiveUnitType(i.isPercentage() ? CSSUnitType::CSS_PERCENTAGE : CSSUnitType::CSS_INTEGER);
125 m_value.num = static_cast<double>(i.value());
126}
127
128template<> inline CSSPrimitiveValue::operator LineClampValue() const
129{
130 if (primitiveType() == CSSUnitType::CSS_INTEGER)
131 return LineClampValue(value<int>(), LineClamp::LineCount);
132
133 if (primitiveType() == CSSUnitType::CSS_PERCENTAGE)
134 return LineClampValue(value<int>(), LineClamp::Percentage);
135
136 ASSERT_NOT_REACHED();
137 return LineClampValue();
138}
139
140template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ReflectionDirection direction)
141 : CSSValue(PrimitiveClass)
142{
143 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
144 switch (direction) {
145 case ReflectionDirection::Above:
146 m_value.valueID = CSSValueAbove;
147 break;
148 case ReflectionDirection::Below:
149 m_value.valueID = CSSValueBelow;
150 break;
151 case ReflectionDirection::Left:
152 m_value.valueID = CSSValueLeft;
153 break;
154 case ReflectionDirection::Right:
155 m_value.valueID = CSSValueRight;
156 }
157}
158
159template<> inline CSSPrimitiveValue::operator ReflectionDirection() const
160{
161 ASSERT(isValueID());
162
163 switch (m_value.valueID) {
164 case CSSValueAbove:
165 return ReflectionDirection::Above;
166 case CSSValueBelow:
167 return ReflectionDirection::Below;
168 case CSSValueLeft:
169 return ReflectionDirection::Left;
170 case CSSValueRight:
171 return ReflectionDirection::Right;
172 default:
173 break;
174 }
175
176 ASSERT_NOT_REACHED();
177 return ReflectionDirection::Below;
178}
179
180template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ColumnFill columnFill)
181 : CSSValue(PrimitiveClass)
182{
183 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
184 switch (columnFill) {
185 case ColumnFill::Auto:
186 m_value.valueID = CSSValueAuto;
187 break;
188 case ColumnFill::Balance:
189 m_value.valueID = CSSValueBalance;
190 break;
191 }
192}
193
194template<> inline CSSPrimitiveValue::operator ColumnFill() const
195{
196 if (primitiveUnitType() == CSSUnitType::CSS_VALUE_ID) {
197 if (m_value.valueID == CSSValueBalance)
198 return ColumnFill::Balance;
199 if (m_value.valueID == CSSValueAuto)
200 return ColumnFill::Auto;
201 }
202 ASSERT_NOT_REACHED();
203 return ColumnFill::Balance;
204}
205
206template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ColumnSpan columnSpan)
207 : CSSValue(PrimitiveClass)
208{
209 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
210 switch (columnSpan) {
211 case ColumnSpan::All:
212 m_value.valueID = CSSValueAll;
213 break;
214 case ColumnSpan::None:
215 m_value.valueID = CSSValueNone;
216 break;
217 }
218}
219
220template<> inline CSSPrimitiveValue::operator ColumnSpan() const
221{
222 // Map 1 to none for compatibility reasons.
223 if ((primitiveUnitType() == CSSUnitType::CSS_NUMBER || primitiveUnitType() == CSSUnitType::CSS_INTEGER) && m_value.num == 1)
224 return ColumnSpan::None;
225
226 ASSERT(isValueID());
227
228 switch (m_value.valueID) {
229 case CSSValueAll:
230 return ColumnSpan::All;
231 case CSSValueNone:
232 return ColumnSpan::None;
233 default:
234 break;
235 }
236
237 ASSERT_NOT_REACHED();
238 return ColumnSpan::None;
239}
240
241
242template<> inline CSSPrimitiveValue::CSSPrimitiveValue(PrintColorAdjust value)
243 : CSSValue(PrimitiveClass)
244{
245 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
246 switch (value) {
247 case PrintColorAdjust::Exact:
248 m_value.valueID = CSSValueExact;
249 break;
250 case PrintColorAdjust::Economy:
251 m_value.valueID = CSSValueEconomy;
252 break;
253 }
254}
255
256template<> inline CSSPrimitiveValue::operator PrintColorAdjust() const
257{
258 ASSERT(isValueID());
259
260 switch (m_value.valueID) {
261 case CSSValueEconomy:
262 return PrintColorAdjust::Economy;
263 case CSSValueExact:
264 return PrintColorAdjust::Exact;
265 default:
266 break;
267 }
268
269 ASSERT_NOT_REACHED();
270 return PrintColorAdjust::Economy;
271}
272
273
274template<> inline CSSPrimitiveValue::CSSPrimitiveValue(BorderStyle e)
275 : CSSValue(PrimitiveClass)
276{
277 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
278 switch (e) {
279 case BorderStyle::None:
280 m_value.valueID = CSSValueNone;
281 break;
282 case BorderStyle::Hidden:
283 m_value.valueID = CSSValueHidden;
284 break;
285 case BorderStyle::Inset:
286 m_value.valueID = CSSValueInset;
287 break;
288 case BorderStyle::Groove:
289 m_value.valueID = CSSValueGroove;
290 break;
291 case BorderStyle::Ridge:
292 m_value.valueID = CSSValueRidge;
293 break;
294 case BorderStyle::Outset:
295 m_value.valueID = CSSValueOutset;
296 break;
297 case BorderStyle::Dotted:
298 m_value.valueID = CSSValueDotted;
299 break;
300 case BorderStyle::Dashed:
301 m_value.valueID = CSSValueDashed;
302 break;
303 case BorderStyle::Solid:
304 m_value.valueID = CSSValueSolid;
305 break;
306 case BorderStyle::Double:
307 m_value.valueID = CSSValueDouble;
308 break;
309 }
310}
311
312template<> inline CSSPrimitiveValue::operator BorderStyle() const
313{
314 ASSERT(isValueID());
315
316 if (m_value.valueID == CSSValueAuto) // Valid for CSS outline-style
317 return BorderStyle::Dotted;
318 return static_cast<BorderStyle>(m_value.valueID - CSSValueNone);
319}
320
321template<> inline CSSPrimitiveValue::operator OutlineIsAuto() const
322{
323 ASSERT(isValueID());
324
325 if (m_value.valueID == CSSValueAuto)
326 return OutlineIsAuto::On;
327 return OutlineIsAuto::Off;
328}
329
330template<> inline CSSPrimitiveValue::CSSPrimitiveValue(CompositeOperator e, CSSPropertyID propertyID)
331 : CSSValue(PrimitiveClass)
332{
333 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
334 if (propertyID == CSSPropertyMaskComposite) {
335 switch (e) {
336 case CompositeOperator::SourceOver:
337 m_value.valueID = CSSValueAdd;
338 break;
339 case CompositeOperator::SourceIn:
340 m_value.valueID = CSSValueIntersect;
341 break;
342 case CompositeOperator::SourceOut:
343 m_value.valueID = CSSValueSubtract;
344 break;
345 case CompositeOperator::XOR:
346 m_value.valueID = CSSValueExclude;
347 break;
348 default:
349 ASSERT_NOT_REACHED();
350 break;
351 }
352 return;
353 }
354 switch (e) {
355 case CompositeOperator::Clear:
356 m_value.valueID = CSSValueClear;
357 break;
358 case CompositeOperator::Copy:
359 m_value.valueID = CSSValueCopy;
360 break;
361 case CompositeOperator::SourceOver:
362 m_value.valueID = CSSValueSourceOver;
363 break;
364 case CompositeOperator::SourceIn:
365 m_value.valueID = CSSValueSourceIn;
366 break;
367 case CompositeOperator::SourceOut:
368 m_value.valueID = CSSValueSourceOut;
369 break;
370 case CompositeOperator::SourceAtop:
371 m_value.valueID = CSSValueSourceAtop;
372 break;
373 case CompositeOperator::DestinationOver:
374 m_value.valueID = CSSValueDestinationOver;
375 break;
376 case CompositeOperator::DestinationIn:
377 m_value.valueID = CSSValueDestinationIn;
378 break;
379 case CompositeOperator::DestinationOut:
380 m_value.valueID = CSSValueDestinationOut;
381 break;
382 case CompositeOperator::DestinationAtop:
383 m_value.valueID = CSSValueDestinationAtop;
384 break;
385 case CompositeOperator::XOR:
386 m_value.valueID = CSSValueXor;
387 break;
388 case CompositeOperator::PlusDarker:
389 m_value.valueID = CSSValuePlusDarker;
390 break;
391 case CompositeOperator::PlusLighter:
392 m_value.valueID = CSSValuePlusLighter;
393 break;
394 case CompositeOperator::Difference:
395 ASSERT_NOT_REACHED();
396 break;
397 }
398}
399
400template<> inline CSSPrimitiveValue::operator CompositeOperator() const
401{
402 ASSERT(isValueID());
403
404 switch (m_value.valueID) {
405 case CSSValueClear:
406 return CompositeOperator::Clear;
407 case CSSValueCopy:
408 return CompositeOperator::Copy;
409 case CSSValueSourceOver:
410 case CSSValueAdd:
411 return CompositeOperator::SourceOver;
412 case CSSValueSourceIn:
413 case CSSValueIntersect:
414 return CompositeOperator::SourceIn;
415 case CSSValueSourceOut:
416 case CSSValueSubtract:
417 return CompositeOperator::SourceOut;
418 case CSSValueSourceAtop:
419 return CompositeOperator::SourceAtop;
420 case CSSValueDestinationOver:
421 return CompositeOperator::DestinationOver;
422 case CSSValueDestinationIn:
423 return CompositeOperator::DestinationIn;
424 case CSSValueDestinationOut:
425 return CompositeOperator::DestinationOut;
426 case CSSValueDestinationAtop:
427 return CompositeOperator::DestinationAtop;
428 case CSSValueXor:
429 case CSSValueExclude:
430 return CompositeOperator::XOR;
431 case CSSValuePlusDarker:
432 return CompositeOperator::PlusDarker;
433 case CSSValuePlusLighter:
434 return CompositeOperator::PlusLighter;
435 default:
436 break;
437 }
438
439 ASSERT_NOT_REACHED();
440 return CompositeOperator::Clear;
441}
442
443template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ControlPart e)
444 : CSSValue(PrimitiveClass)
445{
446 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
447 switch (e) {
448 case NoControlPart:
449 m_value.valueID = CSSValueNone;
450 break;
451 case AutoPart:
452 m_value.valueID = CSSValueAuto;
453 break;
454 case CheckboxPart:
455 m_value.valueID = CSSValueCheckbox;
456 break;
457 case RadioPart:
458 m_value.valueID = CSSValueRadio;
459 break;
460 case PushButtonPart:
461 m_value.valueID = CSSValuePushButton;
462 break;
463 case SquareButtonPart:
464 m_value.valueID = CSSValueSquareButton;
465 break;
466 case ButtonPart:
467 m_value.valueID = CSSValueButton;
468 break;
469 case DefaultButtonPart:
470 m_value.valueID = CSSValueDefaultButton;
471 break;
472 case ListboxPart:
473 m_value.valueID = CSSValueListbox;
474 break;
475 case MenulistPart:
476 m_value.valueID = CSSValueMenulist;
477 break;
478 case MenulistButtonPart:
479 m_value.valueID = CSSValueMenulistButton;
480 break;
481 case MeterPart:
482 m_value.valueID = CSSValueMeter;
483 break;
484 case ProgressBarPart:
485 m_value.valueID = CSSValueProgressBar;
486 break;
487 case SliderHorizontalPart:
488 m_value.valueID = CSSValueSliderHorizontal;
489 break;
490 case SliderVerticalPart:
491 m_value.valueID = CSSValueSliderVertical;
492 break;
493 case SearchFieldPart:
494 m_value.valueID = CSSValueSearchfield;
495 break;
496 case TextFieldPart:
497 m_value.valueID = CSSValueTextfield;
498 break;
499 case TextAreaPart:
500 m_value.valueID = CSSValueTextarea;
501 break;
502#if ENABLE(ATTACHMENT_ELEMENT)
503 case AttachmentPart:
504 m_value.valueID = CSSValueAttachment;
505 break;
506 case BorderlessAttachmentPart:
507 m_value.valueID = CSSValueBorderlessAttachment;
508 break;
509#endif
510#if ENABLE(APPLE_PAY)
511 case ApplePayButtonPart:
512 m_value.valueID = CSSValueApplePayButton;
513 break;
514#endif
515 case CapsLockIndicatorPart:
516#if ENABLE(INPUT_TYPE_COLOR)
517 case ColorWellPart:
518#endif
519#if ENABLE(SERVICE_CONTROLS)
520 case ImageControlsButtonPart:
521#endif
522 case InnerSpinButtonPart:
523#if ENABLE(DATALIST_ELEMENT)
524 case ListButtonPart:
525#endif
526 case SearchFieldDecorationPart:
527 case SearchFieldResultsDecorationPart:
528 case SearchFieldResultsButtonPart:
529 case SearchFieldCancelButtonPart:
530 case SliderThumbHorizontalPart:
531 case SliderThumbVerticalPart:
532 ASSERT_NOT_REACHED();
533 m_value.valueID = CSSValueNone;
534 break;
535 }
536}
537
538template<> inline CSSPrimitiveValue::operator ControlPart() const
539{
540 ASSERT(isValueID());
541
542 if (m_value.valueID == CSSValueNone)
543 return NoControlPart;
544
545 if (m_value.valueID == CSSValueAuto)
546 return AutoPart;
547
548 return ControlPart(m_value.valueID - CSSValueCheckbox + CheckboxPart);
549}
550
551template<> inline CSSPrimitiveValue::CSSPrimitiveValue(BackfaceVisibility e)
552 : CSSValue(PrimitiveClass)
553{
554 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
555 switch (e) {
556 case BackfaceVisibility::Visible:
557 m_value.valueID = CSSValueVisible;
558 break;
559 case BackfaceVisibility::Hidden:
560 m_value.valueID = CSSValueHidden;
561 break;
562 }
563}
564
565template<> inline CSSPrimitiveValue::operator BackfaceVisibility() const
566{
567 ASSERT(isValueID());
568
569 switch (m_value.valueID) {
570 case CSSValueVisible:
571 return BackfaceVisibility::Visible;
572 case CSSValueHidden:
573 return BackfaceVisibility::Hidden;
574 default:
575 break;
576 }
577
578 ASSERT_NOT_REACHED();
579 return BackfaceVisibility::Hidden;
580}
581
582
583template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FillAttachment e)
584 : CSSValue(PrimitiveClass)
585{
586 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
587 switch (e) {
588 case FillAttachment::ScrollBackground:
589 m_value.valueID = CSSValueScroll;
590 break;
591 case FillAttachment::LocalBackground:
592 m_value.valueID = CSSValueLocal;
593 break;
594 case FillAttachment::FixedBackground:
595 m_value.valueID = CSSValueFixed;
596 break;
597 }
598}
599
600template<> inline CSSPrimitiveValue::operator FillAttachment() const
601{
602 ASSERT(isValueID());
603
604 switch (m_value.valueID) {
605 case CSSValueScroll:
606 return FillAttachment::ScrollBackground;
607 case CSSValueLocal:
608 return FillAttachment::LocalBackground;
609 case CSSValueFixed:
610 return FillAttachment::FixedBackground;
611 default:
612 break;
613 }
614
615 ASSERT_NOT_REACHED();
616 return FillAttachment::ScrollBackground;
617}
618
619template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FillBox e)
620 : CSSValue(PrimitiveClass)
621{
622 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
623 switch (e) {
624 case FillBox::Border:
625 m_value.valueID = CSSValueBorderBox;
626 break;
627 case FillBox::Padding:
628 m_value.valueID = CSSValuePaddingBox;
629 break;
630 case FillBox::Content:
631 m_value.valueID = CSSValueContentBox;
632 break;
633 case FillBox::Text:
634 m_value.valueID = CSSValueText;
635 break;
636 case FillBox::NoClip:
637 m_value.valueID = CSSValueNoClip;
638 break;
639 }
640}
641
642template<> inline CSSPrimitiveValue::operator FillBox() const
643{
644 ASSERT(isValueID());
645
646 switch (m_value.valueID) {
647 case CSSValueBorder:
648 case CSSValueBorderBox:
649 return FillBox::Border;
650 case CSSValuePadding:
651 case CSSValuePaddingBox:
652 return FillBox::Padding;
653 case CSSValueContent:
654 case CSSValueContentBox:
655 return FillBox::Content;
656 case CSSValueText:
657 case CSSValueWebkitText:
658 return FillBox::Text;
659 case CSSValueNoClip:
660 return FillBox::NoClip;
661 default:
662 break;
663 }
664
665 ASSERT_NOT_REACHED();
666 return FillBox::Border;
667}
668
669template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FillRepeat e)
670 : CSSValue(PrimitiveClass)
671{
672 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
673 switch (e) {
674 case FillRepeat::Repeat:
675 m_value.valueID = CSSValueRepeat;
676 break;
677 case FillRepeat::NoRepeat:
678 m_value.valueID = CSSValueNoRepeat;
679 break;
680 case FillRepeat::Round:
681 m_value.valueID = CSSValueRound;
682 break;
683 case FillRepeat::Space:
684 m_value.valueID = CSSValueSpace;
685 break;
686 }
687}
688
689template<> inline CSSPrimitiveValue::operator FillRepeat() const
690{
691 ASSERT(isValueID());
692
693 switch (m_value.valueID) {
694 case CSSValueRepeat:
695 return FillRepeat::Repeat;
696 case CSSValueNoRepeat:
697 return FillRepeat::NoRepeat;
698 case CSSValueRound:
699 return FillRepeat::Round;
700 case CSSValueSpace:
701 return FillRepeat::Space;
702 default:
703 break;
704 }
705
706 ASSERT_NOT_REACHED();
707 return FillRepeat::Repeat;
708}
709
710template<> inline CSSPrimitiveValue::CSSPrimitiveValue(BoxPack e)
711 : CSSValue(PrimitiveClass)
712{
713 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
714 switch (e) {
715 case BoxPack::Start:
716 m_value.valueID = CSSValueStart;
717 break;
718 case BoxPack::Center:
719 m_value.valueID = CSSValueCenter;
720 break;
721 case BoxPack::End:
722 m_value.valueID = CSSValueEnd;
723 break;
724 case BoxPack::Justify:
725 m_value.valueID = CSSValueJustify;
726 break;
727 }
728}
729
730template<> inline CSSPrimitiveValue::operator BoxPack() const
731{
732 ASSERT(isValueID());
733
734 switch (m_value.valueID) {
735 case CSSValueStart:
736 return BoxPack::Start;
737 case CSSValueEnd:
738 return BoxPack::End;
739 case CSSValueCenter:
740 return BoxPack::Center;
741 case CSSValueJustify:
742 return BoxPack::Justify;
743 default:
744 break;
745 }
746
747 ASSERT_NOT_REACHED();
748 return BoxPack::Justify;
749}
750
751template<> inline CSSPrimitiveValue::CSSPrimitiveValue(BoxAlignment e)
752 : CSSValue(PrimitiveClass)
753{
754 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
755 switch (e) {
756 case BoxAlignment::Stretch:
757 m_value.valueID = CSSValueStretch;
758 break;
759 case BoxAlignment::Start:
760 m_value.valueID = CSSValueStart;
761 break;
762 case BoxAlignment::Center:
763 m_value.valueID = CSSValueCenter;
764 break;
765 case BoxAlignment::End:
766 m_value.valueID = CSSValueEnd;
767 break;
768 case BoxAlignment::Baseline:
769 m_value.valueID = CSSValueBaseline;
770 break;
771 }
772}
773
774template<> inline CSSPrimitiveValue::operator BoxAlignment() const
775{
776 ASSERT(isValueID());
777
778 switch (m_value.valueID) {
779 case CSSValueStretch:
780 return BoxAlignment::Stretch;
781 case CSSValueStart:
782 return BoxAlignment::Start;
783 case CSSValueEnd:
784 return BoxAlignment::End;
785 case CSSValueCenter:
786 return BoxAlignment::Center;
787 case CSSValueBaseline:
788 return BoxAlignment::Baseline;
789 default:
790 break;
791 }
792
793 ASSERT_NOT_REACHED();
794 return BoxAlignment::Stretch;
795}
796
797#if ENABLE(CSS_BOX_DECORATION_BREAK)
798template<> inline CSSPrimitiveValue::CSSPrimitiveValue(BoxDecorationBreak e)
799 : CSSValue(PrimitiveClass)
800{
801 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
802 switch (e) {
803 case BoxDecorationBreak::Slice:
804 m_value.valueID = CSSValueSlice;
805 break;
806 case BoxDecorationBreak::Clone:
807 m_value.valueID = CSSValueClone;
808 break;
809 }
810}
811
812template<> inline CSSPrimitiveValue::operator BoxDecorationBreak() const
813{
814 ASSERT(isValueID());
815
816 switch (m_value.valueID) {
817 case CSSValueSlice:
818 return BoxDecorationBreak::Slice;
819 case CSSValueClone:
820 return BoxDecorationBreak::Clone;
821 default:
822 break;
823 }
824
825 ASSERT_NOT_REACHED();
826 return BoxDecorationBreak::Slice;
827}
828#endif
829
830template<> inline CSSPrimitiveValue::CSSPrimitiveValue(Edge e)
831 : CSSValue(PrimitiveClass)
832{
833 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
834 switch (e) {
835 case Edge::Top:
836 m_value.valueID = CSSValueTop;
837 break;
838 case Edge::Right:
839 m_value.valueID = CSSValueRight;
840 break;
841 case Edge::Bottom:
842 m_value.valueID = CSSValueBottom;
843 break;
844 case Edge::Left:
845 m_value.valueID = CSSValueLeft;
846 break;
847 }
848}
849
850template<> inline CSSPrimitiveValue::operator Edge() const
851{
852 ASSERT(isValueID());
853
854 switch (m_value.valueID) {
855 case CSSValueTop:
856 return Edge::Top;
857 case CSSValueRight:
858 return Edge::Right;
859 case CSSValueBottom:
860 return Edge::Bottom;
861 case CSSValueLeft:
862 return Edge::Left;
863 default:
864 break;
865 }
866
867 ASSERT_NOT_REACHED();
868 return Edge::Top;
869}
870
871template<> inline CSSPrimitiveValue::CSSPrimitiveValue(BoxSizing e)
872 : CSSValue(PrimitiveClass)
873{
874 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
875 switch (e) {
876 case BoxSizing::BorderBox:
877 m_value.valueID = CSSValueBorderBox;
878 break;
879 case BoxSizing::ContentBox:
880 m_value.valueID = CSSValueContentBox;
881 break;
882 }
883}
884
885template<> inline CSSPrimitiveValue::operator BoxSizing() const
886{
887 ASSERT(isValueID());
888
889 switch (m_value.valueID) {
890 case CSSValueBorderBox:
891 return BoxSizing::BorderBox;
892 case CSSValueContentBox:
893 return BoxSizing::ContentBox;
894 default:
895 break;
896 }
897
898 ASSERT_NOT_REACHED();
899 return BoxSizing::BorderBox;
900}
901
902template<> inline CSSPrimitiveValue::CSSPrimitiveValue(BoxDirection e)
903 : CSSValue(PrimitiveClass)
904{
905 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
906 switch (e) {
907 case BoxDirection::Normal:
908 m_value.valueID = CSSValueNormal;
909 break;
910 case BoxDirection::Reverse:
911 m_value.valueID = CSSValueReverse;
912 break;
913 }
914}
915
916template<> inline CSSPrimitiveValue::operator BoxDirection() const
917{
918 ASSERT(isValueID());
919
920 switch (m_value.valueID) {
921 case CSSValueNormal:
922 return BoxDirection::Normal;
923 case CSSValueReverse:
924 return BoxDirection::Reverse;
925 default:
926 break;
927 }
928
929 ASSERT_NOT_REACHED();
930 return BoxDirection::Normal;
931}
932
933template<> inline CSSPrimitiveValue::CSSPrimitiveValue(BoxLines e)
934 : CSSValue(PrimitiveClass)
935{
936 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
937 switch (e) {
938 case BoxLines::Single:
939 m_value.valueID = CSSValueSingle;
940 break;
941 case BoxLines::Multiple:
942 m_value.valueID = CSSValueMultiple;
943 break;
944 }
945}
946
947template<> inline CSSPrimitiveValue::operator BoxLines() const
948{
949 ASSERT(isValueID());
950
951 switch (m_value.valueID) {
952 case CSSValueSingle:
953 return BoxLines::Single;
954 case CSSValueMultiple:
955 return BoxLines::Multiple;
956 default:
957 break;
958 }
959
960 ASSERT_NOT_REACHED();
961 return BoxLines::Single;
962}
963
964template<> inline CSSPrimitiveValue::CSSPrimitiveValue(BoxOrient e)
965 : CSSValue(PrimitiveClass)
966{
967 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
968 switch (e) {
969 case BoxOrient::Horizontal:
970 m_value.valueID = CSSValueHorizontal;
971 break;
972 case BoxOrient::Vertical:
973 m_value.valueID = CSSValueVertical;
974 break;
975 }
976}
977
978template<> inline CSSPrimitiveValue::operator BoxOrient() const
979{
980 ASSERT(isValueID());
981
982 switch (m_value.valueID) {
983 case CSSValueHorizontal:
984 case CSSValueInlineAxis:
985 return BoxOrient::Horizontal;
986 case CSSValueVertical:
987 case CSSValueBlockAxis:
988 return BoxOrient::Vertical;
989 default:
990 break;
991 }
992
993 ASSERT_NOT_REACHED();
994 return BoxOrient::Horizontal;
995}
996
997template<> inline CSSPrimitiveValue::CSSPrimitiveValue(CaptionSide e)
998 : CSSValue(PrimitiveClass)
999{
1000 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
1001 switch (e) {
1002 case CaptionSide::Left:
1003 m_value.valueID = CSSValueLeft;
1004 break;
1005 case CaptionSide::Right:
1006 m_value.valueID = CSSValueRight;
1007 break;
1008 case CaptionSide::Top:
1009 m_value.valueID = CSSValueTop;
1010 break;
1011 case CaptionSide::Bottom:
1012 m_value.valueID = CSSValueBottom;
1013 break;
1014 }
1015}
1016
1017template<> inline CSSPrimitiveValue::operator CaptionSide() const
1018{
1019 ASSERT(isValueID());
1020
1021 switch (m_value.valueID) {
1022 case CSSValueLeft:
1023 return CaptionSide::Left;
1024 case CSSValueRight:
1025 return CaptionSide::Right;
1026 case CSSValueTop:
1027 return CaptionSide::Top;
1028 case CSSValueBottom:
1029 return CaptionSide::Bottom;
1030 default:
1031 break;
1032 }
1033
1034 ASSERT_NOT_REACHED();
1035 return CaptionSide::Top;
1036}
1037
1038template<> inline CSSPrimitiveValue::CSSPrimitiveValue(Clear e)
1039 : CSSValue(PrimitiveClass)
1040{
1041 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
1042 switch (e) {
1043 case Clear::None:
1044 m_value.valueID = CSSValueNone;
1045 break;
1046 case Clear::Left:
1047 m_value.valueID = CSSValueLeft;
1048 break;
1049 case Clear::Right:
1050 m_value.valueID = CSSValueRight;
1051 break;
1052 case Clear::InlineStart:
1053 m_value.valueID = CSSValueInlineStart;
1054 break;
1055 case Clear::InlineEnd:
1056 m_value.valueID = CSSValueInlineEnd;
1057 break;
1058 case Clear::Both:
1059 m_value.valueID = CSSValueBoth;
1060 break;
1061 }
1062}
1063
1064template<> inline CSSPrimitiveValue::operator Clear() const
1065{
1066 ASSERT(isValueID());
1067
1068 switch (m_value.valueID) {
1069 case CSSValueNone:
1070 return Clear::None;
1071 case CSSValueLeft:
1072 return Clear::Left;
1073 case CSSValueRight:
1074 return Clear::Right;
1075 case CSSValueInlineStart:
1076 return Clear::InlineStart;
1077 case CSSValueInlineEnd:
1078 return Clear::InlineEnd;
1079 case CSSValueBoth:
1080 return Clear::Both;
1081 default:
1082 break;
1083 }
1084
1085 ASSERT_NOT_REACHED();
1086 return Clear::None;
1087}
1088
1089template<> inline CSSPrimitiveValue::CSSPrimitiveValue(CursorType e)
1090 : CSSValue(PrimitiveClass)
1091{
1092 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
1093 switch (e) {
1094 case CursorType::Auto:
1095 m_value.valueID = CSSValueAuto;
1096 break;
1097 case CursorType::Default:
1098 m_value.valueID = CSSValueDefault;
1099 break;
1100 case CursorType::None:
1101 m_value.valueID = CSSValueNone;
1102 break;
1103 case CursorType::ContextMenu:
1104 m_value.valueID = CSSValueContextMenu;
1105 break;
1106 case CursorType::Help:
1107 m_value.valueID = CSSValueHelp;
1108 break;
1109 case CursorType::Pointer:
1110 m_value.valueID = CSSValuePointer;
1111 break;
1112 case CursorType::Progress:
1113 m_value.valueID = CSSValueProgress;
1114 break;
1115 case CursorType::Wait:
1116 m_value.valueID = CSSValueWait;
1117 break;
1118 case CursorType::Cell:
1119 m_value.valueID = CSSValueCell;
1120 break;
1121 case CursorType::Crosshair:
1122 m_value.valueID = CSSValueCrosshair;
1123 break;
1124 case CursorType::Text:
1125 m_value.valueID = CSSValueText;
1126 break;
1127 case CursorType::VerticalText:
1128 m_value.valueID = CSSValueVerticalText;
1129 break;
1130 case CursorType::Alias:
1131 m_value.valueID = CSSValueAlias;
1132 break;
1133 case CursorType::Copy:
1134 m_value.valueID = CSSValueCopy;
1135 break;
1136 case CursorType::Move:
1137 m_value.valueID = CSSValueMove;
1138 break;
1139 case CursorType::NoDrop:
1140 m_value.valueID = CSSValueNoDrop;
1141 break;
1142 case CursorType::NotAllowed:
1143 m_value.valueID = CSSValueNotAllowed;
1144 break;
1145 case CursorType::Grab:
1146 m_value.valueID = CSSValueGrab;
1147 break;
1148 case CursorType::Grabbing:
1149 m_value.valueID = CSSValueGrabbing;
1150 break;
1151 case CursorType::EResize:
1152 m_value.valueID = CSSValueEResize;
1153 break;
1154 case CursorType::NResize:
1155 m_value.valueID = CSSValueNResize;
1156 break;
1157 case CursorType::NEResize:
1158 m_value.valueID = CSSValueNeResize;
1159 break;
1160 case CursorType::NWResize:
1161 m_value.valueID = CSSValueNwResize;
1162 break;
1163 case CursorType::SResize:
1164 m_value.valueID = CSSValueSResize;
1165 break;
1166 case CursorType::SEResize:
1167 m_value.valueID = CSSValueSeResize;
1168 break;
1169 case CursorType::SWResize:
1170 m_value.valueID = CSSValueSwResize;
1171 break;
1172 case CursorType::WResize:
1173 m_value.valueID = CSSValueWResize;
1174 break;
1175 case CursorType::EWResize:
1176 m_value.valueID = CSSValueEwResize;
1177 break;
1178 case CursorType::NSResize:
1179 m_value.valueID = CSSValueNsResize;
1180 break;
1181 case CursorType::NESWResize:
1182 m_value.valueID = CSSValueNeswResize;
1183 break;
1184 case CursorType::NWSEResize:
1185 m_value.valueID = CSSValueNwseResize;
1186 break;
1187 case CursorType::ColumnResize:
1188 m_value.valueID = CSSValueColResize;
1189 break;
1190 case CursorType::RowResize:
1191 m_value.valueID = CSSValueRowResize;
1192 break;
1193 case CursorType::AllScroll:
1194 m_value.valueID = CSSValueAllScroll;
1195 break;
1196 case CursorType::ZoomIn:
1197 m_value.valueID = CSSValueZoomIn;
1198 break;
1199 case CursorType::ZoomOut:
1200 m_value.valueID = CSSValueZoomOut;
1201 break;
1202 }
1203}
1204
1205template<> inline CSSPrimitiveValue::operator CursorType() const
1206{
1207 ASSERT(isValueID());
1208 switch (m_value.valueID) {
1209 case CSSValueCopy:
1210 return CursorType::Copy;
1211 case CSSValueWebkitGrab:
1212 return CursorType::Grab;
1213 case CSSValueWebkitGrabbing:
1214 return CursorType::Grabbing;
1215 case CSSValueWebkitZoomIn:
1216 return CursorType::ZoomIn;
1217 case CSSValueWebkitZoomOut:
1218 return CursorType::ZoomOut;
1219 case CSSValueNone:
1220 return CursorType::None;
1221 default:
1222 return static_cast<CursorType>(m_value.valueID - CSSValueAuto);
1223 }
1224}
1225
1226#if ENABLE(CURSOR_VISIBILITY)
1227template<> inline CSSPrimitiveValue::CSSPrimitiveValue(CursorVisibility e)
1228 : CSSValue(PrimitiveClass)
1229{
1230 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
1231 switch (e) {
1232 case CursorVisibility::Auto:
1233 m_value.valueID = CSSValueAuto;
1234 break;
1235 case CursorVisibility::AutoHide:
1236 m_value.valueID = CSSValueAutoHide;
1237 break;
1238 }
1239}
1240
1241template<> inline CSSPrimitiveValue::operator CursorVisibility() const
1242{
1243 ASSERT(isValueID());
1244
1245 if (m_value.valueID == CSSValueAuto)
1246 return CursorVisibility::Auto;
1247 if (m_value.valueID == CSSValueAutoHide)
1248 return CursorVisibility::AutoHide;
1249
1250 ASSERT_NOT_REACHED();
1251 return CursorVisibility::Auto;
1252}
1253#endif
1254
1255template<> inline CSSPrimitiveValue::CSSPrimitiveValue(DisplayType e)
1256 : CSSValue(PrimitiveClass)
1257{
1258 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
1259 switch (e) {
1260 case DisplayType::Inline:
1261 m_value.valueID = CSSValueInline;
1262 break;
1263 case DisplayType::Block:
1264 m_value.valueID = CSSValueBlock;
1265 break;
1266 case DisplayType::ListItem:
1267 m_value.valueID = CSSValueListItem;
1268 break;
1269 case DisplayType::InlineBlock:
1270 m_value.valueID = CSSValueInlineBlock;
1271 break;
1272 case DisplayType::Table:
1273 m_value.valueID = CSSValueTable;
1274 break;
1275 case DisplayType::InlineTable:
1276 m_value.valueID = CSSValueInlineTable;
1277 break;
1278 case DisplayType::TableRowGroup:
1279 m_value.valueID = CSSValueTableRowGroup;
1280 break;
1281 case DisplayType::TableHeaderGroup:
1282 m_value.valueID = CSSValueTableHeaderGroup;
1283 break;
1284 case DisplayType::TableFooterGroup:
1285 m_value.valueID = CSSValueTableFooterGroup;
1286 break;
1287 case DisplayType::TableRow:
1288 m_value.valueID = CSSValueTableRow;
1289 break;
1290 case DisplayType::TableColumnGroup:
1291 m_value.valueID = CSSValueTableColumnGroup;
1292 break;
1293 case DisplayType::TableColumn:
1294 m_value.valueID = CSSValueTableColumn;
1295 break;
1296 case DisplayType::TableCell:
1297 m_value.valueID = CSSValueTableCell;
1298 break;
1299 case DisplayType::TableCaption:
1300 m_value.valueID = CSSValueTableCaption;
1301 break;
1302 case DisplayType::Box:
1303 m_value.valueID = CSSValueWebkitBox;
1304 break;
1305 case DisplayType::InlineBox:
1306 m_value.valueID = CSSValueWebkitInlineBox;
1307 break;
1308 case DisplayType::Flex:
1309 m_value.valueID = CSSValueFlex;
1310 break;
1311 case DisplayType::InlineFlex:
1312 m_value.valueID = CSSValueInlineFlex;
1313 break;
1314 case DisplayType::Grid:
1315 m_value.valueID = CSSValueGrid;
1316 break;
1317 case DisplayType::InlineGrid:
1318 m_value.valueID = CSSValueInlineGrid;
1319 break;
1320 case DisplayType::None:
1321 m_value.valueID = CSSValueNone;
1322 break;
1323 case DisplayType::Contents:
1324 m_value.valueID = CSSValueContents;
1325 break;
1326 case DisplayType::FlowRoot:
1327 m_value.valueID = CSSValueFlowRoot;
1328 break;
1329 }
1330}
1331
1332template<> inline CSSPrimitiveValue::operator DisplayType() const
1333{
1334 ASSERT(isValueID());
1335
1336 if (m_value.valueID == CSSValueNone)
1337 return DisplayType::None;
1338
1339 DisplayType display = static_cast<DisplayType>(m_value.valueID - CSSValueInline);
1340 ASSERT(display >= DisplayType::Inline && display <= DisplayType::None);
1341 return display;
1342}
1343
1344template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EmptyCell e)
1345 : CSSValue(PrimitiveClass)
1346{
1347 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
1348 switch (e) {
1349 case EmptyCell::Show:
1350 m_value.valueID = CSSValueShow;
1351 break;
1352 case EmptyCell::Hide:
1353 m_value.valueID = CSSValueHide;
1354 break;
1355 }
1356}
1357
1358template<> inline CSSPrimitiveValue::operator EmptyCell() const
1359{
1360 ASSERT(isValueID());
1361
1362 switch (m_value.valueID) {
1363 case CSSValueShow:
1364 return EmptyCell::Show;
1365 case CSSValueHide:
1366 return EmptyCell::Hide;
1367 default:
1368 break;
1369 }
1370
1371 ASSERT_NOT_REACHED();
1372 return EmptyCell::Show;
1373}
1374
1375template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FlexDirection e)
1376 : CSSValue(PrimitiveClass)
1377{
1378 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
1379 switch (e) {
1380 case FlexDirection::Row:
1381 m_value.valueID = CSSValueRow;
1382 break;
1383 case FlexDirection::RowReverse:
1384 m_value.valueID = CSSValueRowReverse;
1385 break;
1386 case FlexDirection::Column:
1387 m_value.valueID = CSSValueColumn;
1388 break;
1389 case FlexDirection::ColumnReverse:
1390 m_value.valueID = CSSValueColumnReverse;
1391 break;
1392 }
1393}
1394
1395template<> inline CSSPrimitiveValue::operator FlexDirection() const
1396{
1397 ASSERT(isValueID());
1398
1399 switch (m_value.valueID) {
1400 case CSSValueRow:
1401 return FlexDirection::Row;
1402 case CSSValueRowReverse:
1403 return FlexDirection::RowReverse;
1404 case CSSValueColumn:
1405 return FlexDirection::Column;
1406 case CSSValueColumnReverse:
1407 return FlexDirection::ColumnReverse;
1408 default:
1409 break;
1410 }
1411
1412 ASSERT_NOT_REACHED();
1413 return FlexDirection::Row;
1414}
1415
1416template<> inline CSSPrimitiveValue::CSSPrimitiveValue(AlignContent e)
1417 : CSSValue(PrimitiveClass)
1418{
1419 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
1420 switch (e) {
1421 case AlignContent::FlexStart:
1422 m_value.valueID = CSSValueFlexStart;
1423 break;
1424 case AlignContent::FlexEnd:
1425 m_value.valueID = CSSValueFlexEnd;
1426 break;
1427 case AlignContent::Center:
1428 m_value.valueID = CSSValueCenter;
1429 break;
1430 case AlignContent::SpaceBetween:
1431 m_value.valueID = CSSValueSpaceBetween;
1432 break;
1433 case AlignContent::SpaceAround:
1434 m_value.valueID = CSSValueSpaceAround;
1435 break;
1436 case AlignContent::Stretch:
1437 m_value.valueID = CSSValueStretch;
1438 break;
1439 }
1440}
1441
1442template<> inline CSSPrimitiveValue::operator AlignContent() const
1443{
1444 ASSERT(isValueID());
1445
1446 switch (m_value.valueID) {
1447 case CSSValueFlexStart:
1448 return AlignContent::FlexStart;
1449 case CSSValueFlexEnd:
1450 return AlignContent::FlexEnd;
1451 case CSSValueCenter:
1452 return AlignContent::Center;
1453 case CSSValueSpaceBetween:
1454 return AlignContent::SpaceBetween;
1455 case CSSValueSpaceAround:
1456 return AlignContent::SpaceAround;
1457 case CSSValueStretch:
1458 return AlignContent::Stretch;
1459 default:
1460 break;
1461 }
1462
1463 ASSERT_NOT_REACHED();
1464 return AlignContent::Stretch;
1465}
1466
1467template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FlexWrap e)
1468 : CSSValue(PrimitiveClass)
1469{
1470 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
1471 switch (e) {
1472 case FlexWrap::NoWrap:
1473 m_value.valueID = CSSValueNowrap;
1474 break;
1475 case FlexWrap::Wrap:
1476 m_value.valueID = CSSValueWrap;
1477 break;
1478 case FlexWrap::Reverse:
1479 m_value.valueID = CSSValueWrapReverse;
1480 break;
1481 }
1482}
1483
1484template<> inline CSSPrimitiveValue::operator FlexWrap() const
1485{
1486 ASSERT(isValueID());
1487
1488 switch (m_value.valueID) {
1489 case CSSValueNowrap:
1490 return FlexWrap::NoWrap;
1491 case CSSValueWrap:
1492 return FlexWrap::Wrap;
1493 case CSSValueWrapReverse:
1494 return FlexWrap::Reverse;
1495 default:
1496 break;
1497 }
1498
1499 ASSERT_NOT_REACHED();
1500 return FlexWrap::NoWrap;
1501}
1502
1503template<> inline CSSPrimitiveValue::CSSPrimitiveValue(Float e)
1504 : CSSValue(PrimitiveClass)
1505{
1506 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
1507 switch (e) {
1508 case Float::None:
1509 m_value.valueID = CSSValueNone;
1510 break;
1511 case Float::Left:
1512 m_value.valueID = CSSValueLeft;
1513 break;
1514 case Float::Right:
1515 m_value.valueID = CSSValueRight;
1516 break;
1517 case Float::InlineStart:
1518 m_value.valueID = CSSValueInlineStart;
1519 break;
1520 case Float::InlineEnd:
1521 m_value.valueID = CSSValueInlineEnd;
1522 break;
1523 }
1524}
1525
1526template<> inline CSSPrimitiveValue::operator Float() const
1527{
1528 ASSERT(isValueID());
1529
1530 switch (m_value.valueID) {
1531 case CSSValueLeft:
1532 return Float::Left;
1533 case CSSValueRight:
1534 return Float::Right;
1535 case CSSValueInlineStart:
1536 return Float::InlineStart;
1537 case CSSValueInlineEnd:
1538 return Float::InlineEnd;
1539 case CSSValueNone:
1540 case CSSValueCenter: // Non-standard CSS value.
1541 return Float::None;
1542 default:
1543 break;
1544 }
1545
1546 ASSERT_NOT_REACHED();
1547 return Float::None;
1548}
1549
1550template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineBreak e)
1551 : CSSValue(PrimitiveClass)
1552{
1553 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
1554 switch (e) {
1555 case LineBreak::Auto:
1556 m_value.valueID = CSSValueAuto;
1557 break;
1558 case LineBreak::Loose:
1559 m_value.valueID = CSSValueLoose;
1560 break;
1561 case LineBreak::Normal:
1562 m_value.valueID = CSSValueNormal;
1563 break;
1564 case LineBreak::Strict:
1565 m_value.valueID = CSSValueStrict;
1566 break;
1567 case LineBreak::AfterWhiteSpace:
1568 m_value.valueID = CSSValueAfterWhiteSpace;
1569 break;
1570 case LineBreak::Anywhere:
1571 m_value.valueID = CSSValueAnywhere;
1572 break;
1573 }
1574}
1575
1576template<> inline CSSPrimitiveValue::operator OptionSet<HangingPunctuation>() const
1577{
1578 ASSERT(isValueID());
1579
1580 switch (m_value.valueID) {
1581 case CSSValueNone:
1582 return OptionSet<HangingPunctuation> { };
1583 case CSSValueFirst:
1584 return HangingPunctuation::First;
1585 case CSSValueLast:
1586 return HangingPunctuation::Last;
1587 case CSSValueAllowEnd:
1588 return HangingPunctuation::AllowEnd;
1589 case CSSValueForceEnd:
1590 return HangingPunctuation::ForceEnd;
1591 default:
1592 break;
1593 }
1594
1595 ASSERT_NOT_REACHED();
1596 return OptionSet<HangingPunctuation> { };
1597}
1598
1599template<> inline CSSPrimitiveValue::operator LineBreak() const
1600{
1601 ASSERT(isValueID());
1602
1603 switch (m_value.valueID) {
1604 case CSSValueAuto:
1605 return LineBreak::Auto;
1606 case CSSValueLoose:
1607 return LineBreak::Loose;
1608 case CSSValueNormal:
1609 return LineBreak::Normal;
1610 case CSSValueStrict:
1611 return LineBreak::Strict;
1612 case CSSValueAfterWhiteSpace:
1613 return LineBreak::AfterWhiteSpace;
1614 case CSSValueAnywhere:
1615 return LineBreak::Anywhere;
1616 default:
1617 break;
1618 }
1619
1620 ASSERT_NOT_REACHED();
1621 return LineBreak::Auto;
1622}
1623
1624template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ListStylePosition e)
1625 : CSSValue(PrimitiveClass)
1626{
1627 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
1628 switch (e) {
1629 case ListStylePosition::Outside:
1630 m_value.valueID = CSSValueOutside;
1631 break;
1632 case ListStylePosition::Inside:
1633 m_value.valueID = CSSValueInside;
1634 break;
1635 }
1636}
1637
1638template<> inline CSSPrimitiveValue::operator ListStylePosition() const
1639{
1640 ASSERT(isValueID());
1641
1642 switch (m_value.valueID) {
1643 case CSSValueOutside:
1644 return ListStylePosition::Outside;
1645 case CSSValueInside:
1646 return ListStylePosition::Inside;
1647 default:
1648 break;
1649 }
1650
1651 ASSERT_NOT_REACHED();
1652 return ListStylePosition::Outside;
1653}
1654
1655inline CSSValueID toCSSValueID(ListStyleType style)
1656{
1657 switch (style) {
1658 case ListStyleType::None:
1659 return CSSValueNone;
1660 case ListStyleType::String:
1661 ASSERT_NOT_REACHED();
1662 return CSSValueInvalid;
1663 default:
1664 return static_cast<CSSValueID>(static_cast<int>(CSSValueDisc) + static_cast<uint8_t>(style));
1665 }
1666}
1667
1668template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ListStyleType style)
1669 : CSSValue(PrimitiveClass)
1670{
1671 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
1672 m_value.valueID = toCSSValueID(style);
1673}
1674
1675template<> inline CSSPrimitiveValue::operator ListStyleType() const
1676{
1677 ASSERT(isValueID());
1678
1679 switch (m_value.valueID) {
1680 case CSSValueNone:
1681 return ListStyleType::None;
1682 default:
1683 return static_cast<ListStyleType>(m_value.valueID - CSSValueDisc);
1684 }
1685}
1686
1687template<> inline CSSPrimitiveValue::CSSPrimitiveValue(MarqueeBehavior e)
1688 : CSSValue(PrimitiveClass)
1689{
1690 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
1691 switch (e) {
1692 case MarqueeBehavior::None:
1693 m_value.valueID = CSSValueNone;
1694 break;
1695 case MarqueeBehavior::Scroll:
1696 m_value.valueID = CSSValueScroll;
1697 break;
1698 case MarqueeBehavior::Slide:
1699 m_value.valueID = CSSValueSlide;
1700 break;
1701 case MarqueeBehavior::Alternate:
1702 m_value.valueID = CSSValueAlternate;
1703 break;
1704 }
1705}
1706
1707template<> inline CSSPrimitiveValue::operator MarqueeBehavior() const
1708{
1709 ASSERT(isValueID());
1710
1711 switch (m_value.valueID) {
1712 case CSSValueNone:
1713 return MarqueeBehavior::None;
1714 case CSSValueScroll:
1715 return MarqueeBehavior::Scroll;
1716 case CSSValueSlide:
1717 return MarqueeBehavior::Slide;
1718 case CSSValueAlternate:
1719 return MarqueeBehavior::Alternate;
1720 default:
1721 break;
1722 }
1723
1724 ASSERT_NOT_REACHED();
1725 return MarqueeBehavior::None;
1726}
1727
1728template<> inline CSSPrimitiveValue::CSSPrimitiveValue(MarqueeDirection direction)
1729 : CSSValue(PrimitiveClass)
1730{
1731 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
1732 switch (direction) {
1733 case MarqueeDirection::Forward:
1734 m_value.valueID = CSSValueForwards;
1735 break;
1736 case MarqueeDirection::Backward:
1737 m_value.valueID = CSSValueBackwards;
1738 break;
1739 case MarqueeDirection::Auto:
1740 m_value.valueID = CSSValueAuto;
1741 break;
1742 case MarqueeDirection::Up:
1743 m_value.valueID = CSSValueUp;
1744 break;
1745 case MarqueeDirection::Down:
1746 m_value.valueID = CSSValueDown;
1747 break;
1748 case MarqueeDirection::Left:
1749 m_value.valueID = CSSValueLeft;
1750 break;
1751 case MarqueeDirection::Right:
1752 m_value.valueID = CSSValueRight;
1753 break;
1754 }
1755}
1756
1757template<> inline CSSPrimitiveValue::operator MarqueeDirection() const
1758{
1759 ASSERT(isValueID());
1760
1761 switch (m_value.valueID) {
1762 case CSSValueForwards:
1763 return MarqueeDirection::Forward;
1764 case CSSValueBackwards:
1765 return MarqueeDirection::Backward;
1766 case CSSValueAuto:
1767 return MarqueeDirection::Auto;
1768 case CSSValueAhead:
1769 case CSSValueUp: // We don't support vertical languages, so AHEAD just maps to UP.
1770 return MarqueeDirection::Up;
1771 case CSSValueReverse:
1772 case CSSValueDown: // REVERSE just maps to DOWN, since we don't do vertical text.
1773 return MarqueeDirection::Down;
1774 case CSSValueLeft:
1775 return MarqueeDirection::Left;
1776 case CSSValueRight:
1777 return MarqueeDirection::Right;
1778 default:
1779 break;
1780 }
1781
1782 ASSERT_NOT_REACHED();
1783 return MarqueeDirection::Auto;
1784}
1785
1786template<> inline CSSPrimitiveValue::CSSPrimitiveValue(NBSPMode e)
1787 : CSSValue(PrimitiveClass)
1788{
1789 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
1790 switch (e) {
1791 case NBSPMode::Normal:
1792 m_value.valueID = CSSValueNormal;
1793 break;
1794 case NBSPMode::Space:
1795 m_value.valueID = CSSValueSpace;
1796 break;
1797 }
1798}
1799
1800template<> inline CSSPrimitiveValue::operator NBSPMode() const
1801{
1802 ASSERT(isValueID());
1803
1804 switch (m_value.valueID) {
1805 case CSSValueSpace:
1806 return NBSPMode::Space;
1807 case CSSValueNormal:
1808 return NBSPMode::Normal;
1809 default:
1810 break;
1811 }
1812
1813 ASSERT_NOT_REACHED();
1814 return NBSPMode::Normal;
1815}
1816
1817template<> inline CSSPrimitiveValue::CSSPrimitiveValue(Overflow e)
1818 : CSSValue(PrimitiveClass)
1819{
1820 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
1821 switch (e) {
1822 case Overflow::Visible:
1823 m_value.valueID = CSSValueVisible;
1824 break;
1825 case Overflow::Hidden:
1826 m_value.valueID = CSSValueHidden;
1827 break;
1828 case Overflow::Scroll:
1829 m_value.valueID = CSSValueScroll;
1830 break;
1831 case Overflow::Auto:
1832 m_value.valueID = CSSValueAuto;
1833 break;
1834 case Overflow::PagedX:
1835 m_value.valueID = CSSValueWebkitPagedX;
1836 break;
1837 case Overflow::PagedY:
1838 m_value.valueID = CSSValueWebkitPagedY;
1839 break;
1840 case Overflow::Clip:
1841 m_value.valueID = CSSValueClip;
1842 break;
1843 }
1844}
1845
1846template<> inline CSSPrimitiveValue::operator Overflow() const
1847{
1848 ASSERT(isValueID());
1849
1850 switch (m_value.valueID) {
1851 case CSSValueVisible:
1852 return Overflow::Visible;
1853 case CSSValueHidden:
1854 return Overflow::Hidden;
1855 case CSSValueScroll:
1856 return Overflow::Scroll;
1857 case CSSValueOverlay:
1858 case CSSValueAuto:
1859 return Overflow::Auto;
1860 case CSSValueWebkitPagedX:
1861 return Overflow::PagedX;
1862 case CSSValueWebkitPagedY:
1863 return Overflow::PagedY;
1864 case CSSValueClip:
1865 return Overflow::Clip;
1866 default:
1867 break;
1868 }
1869
1870 ASSERT_NOT_REACHED();
1871 return Overflow::Visible;
1872}
1873
1874template<> inline CSSPrimitiveValue::CSSPrimitiveValue(OverscrollBehavior behavior)
1875 : CSSValue(PrimitiveClass)
1876{
1877 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
1878 switch (behavior) {
1879 case OverscrollBehavior::Contain:
1880 m_value.valueID = CSSValueContain;
1881 break;
1882 case OverscrollBehavior::None:
1883 m_value.valueID = CSSValueNone;
1884 break;
1885 case OverscrollBehavior::Auto:
1886 m_value.valueID = CSSValueAuto;
1887 break;
1888 }
1889}
1890
1891template<> inline CSSPrimitiveValue::operator OverscrollBehavior() const
1892{
1893 ASSERT(isValueID());
1894
1895 switch (m_value.valueID) {
1896 case CSSValueContain:
1897 return OverscrollBehavior::Contain;
1898 case CSSValueNone:
1899 return OverscrollBehavior::None;
1900 case CSSValueAuto:
1901 return OverscrollBehavior::Auto;
1902 default:
1903 break;
1904 }
1905
1906 ASSERT_NOT_REACHED();
1907 return OverscrollBehavior::Auto;
1908}
1909
1910template<> inline CSSPrimitiveValue::CSSPrimitiveValue(BreakBetween e)
1911 : CSSValue(PrimitiveClass)
1912{
1913 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
1914 switch (e) {
1915 case BreakBetween::Auto:
1916 m_value.valueID = CSSValueAuto;
1917 break;
1918 case BreakBetween::Avoid:
1919 m_value.valueID = CSSValueAvoid;
1920 break;
1921 case BreakBetween::AvoidColumn:
1922 m_value.valueID = CSSValueAvoidColumn;
1923 break;
1924 case BreakBetween::AvoidPage:
1925 m_value.valueID = CSSValueAvoidPage;
1926 break;
1927 case BreakBetween::Column:
1928 m_value.valueID = CSSValueColumn;
1929 break;
1930 case BreakBetween::Page:
1931 m_value.valueID = CSSValuePage;
1932 break;
1933 case BreakBetween::LeftPage:
1934 m_value.valueID = CSSValueLeft;
1935 break;
1936 case BreakBetween::RightPage:
1937 m_value.valueID = CSSValueRight;
1938 break;
1939 case BreakBetween::RectoPage:
1940 m_value.valueID = CSSValueRecto;
1941 break;
1942 case BreakBetween::VersoPage:
1943 m_value.valueID = CSSValueVerso;
1944 break;
1945 }
1946}
1947
1948template<> inline CSSPrimitiveValue::operator BreakBetween() const
1949{
1950 ASSERT(isValueID());
1951
1952 switch (m_value.valueID) {
1953 case CSSValueAuto:
1954 return BreakBetween::Auto;
1955 case CSSValueAvoid:
1956 return BreakBetween::Avoid;
1957 case CSSValueAvoidColumn:
1958 return BreakBetween::AvoidColumn;
1959 case CSSValueAvoidPage:
1960 return BreakBetween::AvoidPage;
1961 case CSSValueColumn:
1962 return BreakBetween::Column;
1963 case CSSValuePage:
1964 return BreakBetween::Page;
1965 case CSSValueLeft:
1966 return BreakBetween::LeftPage;
1967 case CSSValueRight:
1968 return BreakBetween::RightPage;
1969 case CSSValueRecto:
1970 return BreakBetween::RectoPage;
1971 case CSSValueVerso:
1972 return BreakBetween::VersoPage;
1973 default:
1974 break;
1975 }
1976
1977 ASSERT_NOT_REACHED();
1978 return BreakBetween::Auto;
1979}
1980
1981template<> inline CSSPrimitiveValue::CSSPrimitiveValue(BreakInside e)
1982 : CSSValue(PrimitiveClass)
1983{
1984 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
1985 switch (e) {
1986 case BreakInside::Auto:
1987 m_value.valueID = CSSValueAuto;
1988 break;
1989 case BreakInside::Avoid:
1990 m_value.valueID = CSSValueAvoid;
1991 break;
1992 case BreakInside::AvoidColumn:
1993 m_value.valueID = CSSValueAvoidColumn;
1994 break;
1995 case BreakInside::AvoidPage:
1996 m_value.valueID = CSSValueAvoidPage;
1997 break;
1998 }
1999}
2000
2001template<> inline CSSPrimitiveValue::operator BreakInside() const
2002{
2003 ASSERT(isValueID());
2004
2005 switch (m_value.valueID) {
2006 case CSSValueAuto:
2007 return BreakInside::Auto;
2008 case CSSValueAvoid:
2009 return BreakInside::Avoid;
2010 case CSSValueAvoidColumn:
2011 return BreakInside::AvoidColumn;
2012 case CSSValueAvoidPage:
2013 return BreakInside::AvoidPage;
2014 default:
2015 break;
2016 }
2017
2018 ASSERT_NOT_REACHED();
2019 return BreakInside::Auto;
2020}
2021
2022template<> inline CSSPrimitiveValue::CSSPrimitiveValue(PositionType e)
2023 : CSSValue(PrimitiveClass)
2024{
2025 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
2026 switch (e) {
2027 case PositionType::Static:
2028 m_value.valueID = CSSValueStatic;
2029 break;
2030 case PositionType::Relative:
2031 m_value.valueID = CSSValueRelative;
2032 break;
2033 case PositionType::Absolute:
2034 m_value.valueID = CSSValueAbsolute;
2035 break;
2036 case PositionType::Fixed:
2037 m_value.valueID = CSSValueFixed;
2038 break;
2039 case PositionType::Sticky:
2040 m_value.valueID = CSSValueSticky;
2041 break;
2042 }
2043}
2044
2045template<> inline CSSPrimitiveValue::operator PositionType() const
2046{
2047 ASSERT(isValueID());
2048
2049 switch (m_value.valueID) {
2050 case CSSValueStatic:
2051 return PositionType::Static;
2052 case CSSValueRelative:
2053 return PositionType::Relative;
2054 case CSSValueAbsolute:
2055 return PositionType::Absolute;
2056 case CSSValueFixed:
2057 return PositionType::Fixed;
2058 case CSSValueSticky:
2059 case CSSValueWebkitSticky:
2060 return PositionType::Sticky;
2061 default:
2062 break;
2063 }
2064
2065 ASSERT_NOT_REACHED();
2066 return PositionType::Static;
2067}
2068
2069template<> inline CSSPrimitiveValue::CSSPrimitiveValue(Resize e)
2070 : CSSValue(PrimitiveClass)
2071{
2072 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
2073 switch (e) {
2074 case Resize::Both:
2075 m_value.valueID = CSSValueBoth;
2076 break;
2077 case Resize::Horizontal:
2078 m_value.valueID = CSSValueHorizontal;
2079 break;
2080 case Resize::Vertical:
2081 m_value.valueID = CSSValueVertical;
2082 break;
2083 case Resize::Block:
2084 m_value.valueID = CSSValueBlock;
2085 break;
2086 case Resize::Inline:
2087 m_value.valueID = CSSValueInline;
2088 break;
2089 case Resize::None:
2090 m_value.valueID = CSSValueNone;
2091 break;
2092 }
2093}
2094
2095template<> inline CSSPrimitiveValue::operator Resize() const
2096{
2097 ASSERT(isValueID());
2098
2099 switch (m_value.valueID) {
2100 case CSSValueBoth:
2101 return Resize::Both;
2102 case CSSValueHorizontal:
2103 return Resize::Horizontal;
2104 case CSSValueVertical:
2105 return Resize::Vertical;
2106 case CSSValueBlock:
2107 return Resize::Block;
2108 case CSSValueInline:
2109 return Resize::Inline;
2110 case CSSValueAuto:
2111 ASSERT_NOT_REACHED(); // Depends on settings, thus should be handled by the caller.
2112 return Resize::None;
2113 case CSSValueNone:
2114 return Resize::None;
2115 default:
2116 break;
2117 }
2118
2119 ASSERT_NOT_REACHED();
2120 return Resize::None;
2121}
2122
2123template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TableLayoutType e)
2124 : CSSValue(PrimitiveClass)
2125{
2126 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
2127 switch (e) {
2128 case TableLayoutType::Auto:
2129 m_value.valueID = CSSValueAuto;
2130 break;
2131 case TableLayoutType::Fixed:
2132 m_value.valueID = CSSValueFixed;
2133 break;
2134 }
2135}
2136
2137template<> inline CSSPrimitiveValue::operator TableLayoutType() const
2138{
2139 ASSERT(isValueID());
2140
2141 switch (m_value.valueID) {
2142 case CSSValueFixed:
2143 return TableLayoutType::Fixed;
2144 case CSSValueAuto:
2145 return TableLayoutType::Auto;
2146 default:
2147 break;
2148 }
2149
2150 ASSERT_NOT_REACHED();
2151 return TableLayoutType::Auto;
2152}
2153
2154template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextAlignMode e)
2155 : CSSValue(PrimitiveClass)
2156{
2157 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
2158 switch (e) {
2159 case TextAlignMode::Start:
2160 m_value.valueID = CSSValueStart;
2161 break;
2162 case TextAlignMode::End:
2163 m_value.valueID = CSSValueEnd;
2164 break;
2165 case TextAlignMode::Left:
2166 m_value.valueID = CSSValueLeft;
2167 break;
2168 case TextAlignMode::Right:
2169 m_value.valueID = CSSValueRight;
2170 break;
2171 case TextAlignMode::Center:
2172 m_value.valueID = CSSValueCenter;
2173 break;
2174 case TextAlignMode::Justify:
2175 m_value.valueID = CSSValueJustify;
2176 break;
2177 case TextAlignMode::WebKitLeft:
2178 m_value.valueID = CSSValueWebkitLeft;
2179 break;
2180 case TextAlignMode::WebKitRight:
2181 m_value.valueID = CSSValueWebkitRight;
2182 break;
2183 case TextAlignMode::WebKitCenter:
2184 m_value.valueID = CSSValueWebkitCenter;
2185 break;
2186 }
2187}
2188
2189template<> inline CSSPrimitiveValue::operator TextAlignMode() const
2190{
2191 ASSERT(isValueID());
2192
2193 switch (m_value.valueID) {
2194 case CSSValueWebkitAuto: // Legacy -webkit-auto. Eqiuvalent to start.
2195 case CSSValueStart:
2196 return TextAlignMode::Start;
2197 case CSSValueEnd:
2198 return TextAlignMode::End;
2199 default:
2200 return static_cast<TextAlignMode>(m_value.valueID - CSSValueLeft);
2201 }
2202}
2203
2204template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextAlignLast e)
2205 : CSSValue(PrimitiveClass)
2206{
2207 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
2208 switch (e) {
2209 case TextAlignLast::Start:
2210 m_value.valueID = CSSValueStart;
2211 break;
2212 case TextAlignLast::End:
2213 m_value.valueID = CSSValueEnd;
2214 break;
2215 case TextAlignLast::Left:
2216 m_value.valueID = CSSValueLeft;
2217 break;
2218 case TextAlignLast::Right:
2219 m_value.valueID = CSSValueRight;
2220 break;
2221 case TextAlignLast::Center:
2222 m_value.valueID = CSSValueCenter;
2223 break;
2224 case TextAlignLast::Justify:
2225 m_value.valueID = CSSValueJustify;
2226 break;
2227 case TextAlignLast::Auto:
2228 m_value.valueID = CSSValueAuto;
2229 break;
2230 }
2231}
2232
2233template<> inline CSSPrimitiveValue::operator TextAlignLast() const
2234{
2235 ASSERT(isValueID());
2236
2237 switch (m_value.valueID) {
2238 case CSSValueAuto:
2239 return TextAlignLast::Auto;
2240 case CSSValueStart:
2241 return TextAlignLast::Start;
2242 case CSSValueEnd:
2243 return TextAlignLast::End;
2244 case CSSValueLeft:
2245 return TextAlignLast::Left;
2246 case CSSValueRight:
2247 return TextAlignLast::Right;
2248 case CSSValueCenter:
2249 return TextAlignLast::Center;
2250 case CSSValueJustify:
2251 return TextAlignLast::Justify;
2252 default:
2253 break;
2254 }
2255
2256 ASSERT_NOT_REACHED();
2257 return TextAlignLast::Auto;
2258}
2259
2260template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextJustify e)
2261 : CSSValue(PrimitiveClass)
2262{
2263 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
2264 switch (e) {
2265 case TextJustify::Auto:
2266 m_value.valueID = CSSValueAuto;
2267 break;
2268 case TextJustify::None:
2269 m_value.valueID = CSSValueNone;
2270 break;
2271 case TextJustify::InterWord:
2272 m_value.valueID = CSSValueInterWord;
2273 break;
2274 case TextJustify::InterCharacter:
2275 m_value.valueID = CSSValueInterCharacter;
2276 break;
2277 }
2278}
2279
2280template<> inline CSSPrimitiveValue::operator TextJustify() const
2281{
2282 ASSERT(isValueID());
2283
2284 switch (m_value.valueID) {
2285 case CSSValueAuto:
2286 return TextJustify::Auto;
2287 case CSSValueNone:
2288 return TextJustify::None;
2289 case CSSValueInterWord:
2290 return TextJustify::InterWord;
2291 case CSSValueInterCharacter:
2292 case CSSValueDistribute:
2293 return TextJustify::InterCharacter;
2294 default:
2295 break;
2296 }
2297
2298 ASSERT_NOT_REACHED();
2299 return TextJustify::Auto;
2300}
2301
2302template<> inline CSSPrimitiveValue::operator OptionSet<TextDecorationLine>() const
2303{
2304 ASSERT(isValueID());
2305
2306 switch (m_value.valueID) {
2307 case CSSValueNone:
2308 return OptionSet<TextDecorationLine> { };
2309 case CSSValueUnderline:
2310 return TextDecorationLine::Underline;
2311 case CSSValueOverline:
2312 return TextDecorationLine::Overline;
2313 case CSSValueLineThrough:
2314 return TextDecorationLine::LineThrough;
2315 case CSSValueBlink:
2316 return TextDecorationLine::Blink;
2317 default:
2318 break;
2319 }
2320
2321 ASSERT_NOT_REACHED();
2322 return OptionSet<TextDecorationLine> { };
2323}
2324
2325template<> inline CSSPrimitiveValue::operator TextDecorationStyle() const
2326{
2327 ASSERT(isValueID());
2328
2329 switch (m_value.valueID) {
2330 case CSSValueSolid:
2331 return TextDecorationStyle::Solid;
2332 case CSSValueDouble:
2333 return TextDecorationStyle::Double;
2334 case CSSValueDotted:
2335 return TextDecorationStyle::Dotted;
2336 case CSSValueDashed:
2337 return TextDecorationStyle::Dashed;
2338 case CSSValueWavy:
2339 return TextDecorationStyle::Wavy;
2340 default:
2341 break;
2342 }
2343
2344 ASSERT_NOT_REACHED();
2345 return TextDecorationStyle::Solid;
2346}
2347
2348template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextUnderlinePosition position)
2349 : CSSValue(PrimitiveClass)
2350{
2351 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
2352 switch (position) {
2353 case TextUnderlinePosition::Auto:
2354 m_value.valueID = CSSValueAuto;
2355 break;
2356 case TextUnderlinePosition::Under:
2357 m_value.valueID = CSSValueUnder;
2358 break;
2359 case TextUnderlinePosition::FromFont:
2360 m_value.valueID = CSSValueFromFont;
2361 break;
2362 }
2363
2364 // FIXME: Implement support for 'under left' and 'under right' values.
2365}
2366
2367template<> inline CSSPrimitiveValue::operator TextUnderlinePosition() const
2368{
2369 ASSERT(isValueID());
2370
2371 switch (m_value.valueID) {
2372 case CSSValueAuto:
2373 return TextUnderlinePosition::Auto;
2374 case CSSValueUnder:
2375 return TextUnderlinePosition::Under;
2376 case CSSValueFromFont:
2377 return TextUnderlinePosition::FromFont;
2378 default:
2379 break;
2380 }
2381
2382 // FIXME: Implement support for 'under left' and 'under right' values.
2383 ASSERT_NOT_REACHED();
2384 return TextUnderlinePosition::Auto;
2385}
2386
2387template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextSecurity e)
2388 : CSSValue(PrimitiveClass)
2389{
2390 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
2391 switch (e) {
2392 case TextSecurity::None:
2393 m_value.valueID = CSSValueNone;
2394 break;
2395 case TextSecurity::Disc:
2396 m_value.valueID = CSSValueDisc;
2397 break;
2398 case TextSecurity::Circle:
2399 m_value.valueID = CSSValueCircle;
2400 break;
2401 case TextSecurity::Square:
2402 m_value.valueID = CSSValueSquare;
2403 break;
2404 }
2405}
2406
2407template<> inline CSSPrimitiveValue::operator TextSecurity() const
2408{
2409 ASSERT(isValueID());
2410
2411 switch (m_value.valueID) {
2412 case CSSValueNone:
2413 return TextSecurity::None;
2414 case CSSValueDisc:
2415 return TextSecurity::Disc;
2416 case CSSValueCircle:
2417 return TextSecurity::Circle;
2418 case CSSValueSquare:
2419 return TextSecurity::Square;
2420 default:
2421 break;
2422 }
2423
2424 ASSERT_NOT_REACHED();
2425 return TextSecurity::None;
2426}
2427
2428template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextDecorationSkipInk e)
2429 : CSSValue(PrimitiveClass)
2430{
2431 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
2432 switch (e) {
2433 case TextDecorationSkipInk::None:
2434 m_value.valueID = CSSValueNone;
2435 break;
2436 case TextDecorationSkipInk::Auto:
2437 m_value.valueID = CSSValueAuto;
2438 break;
2439 case TextDecorationSkipInk::All:
2440 m_value.valueID = CSSValueAll;
2441 break;
2442 }
2443}
2444
2445template<> inline CSSPrimitiveValue::operator TextDecorationSkipInk() const
2446{
2447 ASSERT(isValueID());
2448
2449 switch (m_value.valueID) {
2450 case CSSValueNone:
2451 return TextDecorationSkipInk::None;
2452 case CSSValueAuto:
2453 return TextDecorationSkipInk::Auto;
2454 case CSSValueAll:
2455 return TextDecorationSkipInk::All;
2456 default:
2457 break;
2458 }
2459
2460 ASSERT_NOT_REACHED();
2461 return TextDecorationSkipInk::None;
2462}
2463
2464template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextTransform e)
2465 : CSSValue(PrimitiveClass)
2466{
2467 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
2468 switch (e) {
2469 case TextTransform::Capitalize:
2470 m_value.valueID = CSSValueCapitalize;
2471 break;
2472 case TextTransform::Uppercase:
2473 m_value.valueID = CSSValueUppercase;
2474 break;
2475 case TextTransform::Lowercase:
2476 m_value.valueID = CSSValueLowercase;
2477 break;
2478 case TextTransform::None:
2479 m_value.valueID = CSSValueNone;
2480 break;
2481 }
2482}
2483
2484template<> inline CSSPrimitiveValue::operator TextTransform() const
2485{
2486 ASSERT(isValueID());
2487
2488 switch (m_value.valueID) {
2489 case CSSValueCapitalize:
2490 return TextTransform::Capitalize;
2491 case CSSValueUppercase:
2492 return TextTransform::Uppercase;
2493 case CSSValueLowercase:
2494 return TextTransform::Lowercase;
2495 case CSSValueNone:
2496 return TextTransform::None;
2497 default:
2498 break;
2499 }
2500
2501 ASSERT_NOT_REACHED();
2502 return TextTransform::None;
2503}
2504
2505template<> inline CSSPrimitiveValue::CSSPrimitiveValue(UnicodeBidi e)
2506 : CSSValue(PrimitiveClass)
2507{
2508 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
2509 switch (e) {
2510 case UnicodeBidi::Normal:
2511 m_value.valueID = CSSValueNormal;
2512 break;
2513 case UnicodeBidi::Embed:
2514 m_value.valueID = CSSValueEmbed;
2515 break;
2516 case UnicodeBidi::Override:
2517 m_value.valueID = CSSValueBidiOverride;
2518 break;
2519 case UnicodeBidi::Isolate:
2520 m_value.valueID = CSSValueIsolate;
2521 break;
2522 case UnicodeBidi::IsolateOverride:
2523 m_value.valueID = CSSValueIsolateOverride;
2524 break;
2525 case UnicodeBidi::Plaintext:
2526 m_value.valueID = CSSValuePlaintext;
2527 break;
2528 }
2529}
2530
2531template<> inline CSSPrimitiveValue::operator UnicodeBidi() const
2532{
2533 ASSERT(isValueID());
2534
2535 switch (m_value.valueID) {
2536 case CSSValueNormal:
2537 return UnicodeBidi::Normal;
2538 case CSSValueEmbed:
2539 return UnicodeBidi::Embed;
2540 case CSSValueBidiOverride:
2541 return UnicodeBidi::Override;
2542 case CSSValueIsolate:
2543 case CSSValueWebkitIsolate:
2544 return UnicodeBidi::Isolate;
2545 case CSSValueIsolateOverride:
2546 case CSSValueWebkitIsolateOverride:
2547 return UnicodeBidi::IsolateOverride;
2548 case CSSValuePlaintext:
2549 case CSSValueWebkitPlaintext:
2550 return UnicodeBidi::Plaintext;
2551 default:
2552 break;
2553 }
2554
2555 ASSERT_NOT_REACHED();
2556 return UnicodeBidi::Normal;
2557}
2558
2559template<> inline CSSPrimitiveValue::CSSPrimitiveValue(UserDrag e)
2560 : CSSValue(PrimitiveClass)
2561{
2562 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
2563 switch (e) {
2564 case UserDrag::Auto:
2565 m_value.valueID = CSSValueAuto;
2566 break;
2567 case UserDrag::None:
2568 m_value.valueID = CSSValueNone;
2569 break;
2570 case UserDrag::Element:
2571 m_value.valueID = CSSValueElement;
2572 break;
2573 default:
2574 break;
2575 }
2576}
2577
2578template<> inline CSSPrimitiveValue::operator UserDrag() const
2579{
2580 ASSERT(isValueID());
2581
2582 switch (m_value.valueID) {
2583 case CSSValueAuto:
2584 return UserDrag::Auto;
2585 case CSSValueNone:
2586 return UserDrag::None;
2587 case CSSValueElement:
2588 return UserDrag::Element;
2589 default:
2590 break;
2591 }
2592
2593 ASSERT_NOT_REACHED();
2594 return UserDrag::Auto;
2595}
2596
2597template<> inline CSSPrimitiveValue::CSSPrimitiveValue(UserModify e)
2598 : CSSValue(PrimitiveClass)
2599{
2600 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
2601 switch (e) {
2602 case UserModify::ReadOnly:
2603 m_value.valueID = CSSValueReadOnly;
2604 break;
2605 case UserModify::ReadWrite:
2606 m_value.valueID = CSSValueReadWrite;
2607 break;
2608 case UserModify::ReadWritePlaintextOnly:
2609 m_value.valueID = CSSValueReadWritePlaintextOnly;
2610 break;
2611 }
2612}
2613
2614template<> inline CSSPrimitiveValue::operator UserModify() const
2615{
2616 ASSERT(isValueID());
2617
2618 switch (m_value.valueID) {
2619 case CSSValueReadOnly:
2620 return UserModify::ReadOnly;
2621 case CSSValueReadWrite:
2622 return UserModify::ReadWrite;
2623 case CSSValueReadWritePlaintextOnly:
2624 return UserModify::ReadWritePlaintextOnly;
2625 default:
2626 break;
2627 }
2628
2629 ASSERT_NOT_REACHED();
2630 return UserModify::ReadOnly;
2631}
2632
2633template<> inline CSSPrimitiveValue::CSSPrimitiveValue(UserSelect e)
2634 : CSSValue(PrimitiveClass)
2635{
2636 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
2637 switch (e) {
2638 case UserSelect::None:
2639 m_value.valueID = CSSValueNone;
2640 break;
2641 case UserSelect::Text:
2642 m_value.valueID = CSSValueText;
2643 break;
2644 case UserSelect::All:
2645 m_value.valueID = CSSValueAll;
2646 break;
2647 }
2648}
2649
2650template<> inline CSSPrimitiveValue::operator UserSelect() const
2651{
2652 ASSERT(isValueID());
2653
2654 switch (m_value.valueID) {
2655 case CSSValueAuto:
2656 return UserSelect::Text;
2657 case CSSValueNone:
2658 return UserSelect::None;
2659 case CSSValueText:
2660 return UserSelect::Text;
2661 case CSSValueAll:
2662 return UserSelect::All;
2663 default:
2664 break;
2665 }
2666
2667 ASSERT_NOT_REACHED();
2668 return UserSelect::Text;
2669}
2670
2671template<> inline CSSPrimitiveValue::CSSPrimitiveValue(VerticalAlign a)
2672 : CSSValue(PrimitiveClass)
2673{
2674 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
2675 switch (a) {
2676 case VerticalAlign::Top:
2677 m_value.valueID = CSSValueTop;
2678 break;
2679 case VerticalAlign::Bottom:
2680 m_value.valueID = CSSValueBottom;
2681 break;
2682 case VerticalAlign::Middle:
2683 m_value.valueID = CSSValueMiddle;
2684 break;
2685 case VerticalAlign::Baseline:
2686 m_value.valueID = CSSValueBaseline;
2687 break;
2688 case VerticalAlign::TextBottom:
2689 m_value.valueID = CSSValueTextBottom;
2690 break;
2691 case VerticalAlign::TextTop:
2692 m_value.valueID = CSSValueTextTop;
2693 break;
2694 case VerticalAlign::Sub:
2695 m_value.valueID = CSSValueSub;
2696 break;
2697 case VerticalAlign::Super:
2698 m_value.valueID = CSSValueSuper;
2699 break;
2700 case VerticalAlign::BaselineMiddle:
2701 m_value.valueID = CSSValueWebkitBaselineMiddle;
2702 break;
2703 case VerticalAlign::Length:
2704 m_value.valueID = CSSValueInvalid;
2705 }
2706}
2707
2708template<> inline CSSPrimitiveValue::operator VerticalAlign() const
2709{
2710 ASSERT(isValueID());
2711
2712 switch (m_value.valueID) {
2713 case CSSValueTop:
2714 return VerticalAlign::Top;
2715 case CSSValueBottom:
2716 return VerticalAlign::Bottom;
2717 case CSSValueMiddle:
2718 return VerticalAlign::Middle;
2719 case CSSValueBaseline:
2720 return VerticalAlign::Baseline;
2721 case CSSValueTextBottom:
2722 return VerticalAlign::TextBottom;
2723 case CSSValueTextTop:
2724 return VerticalAlign::TextTop;
2725 case CSSValueSub:
2726 return VerticalAlign::Sub;
2727 case CSSValueSuper:
2728 return VerticalAlign::Super;
2729 case CSSValueWebkitBaselineMiddle:
2730 return VerticalAlign::BaselineMiddle;
2731 default:
2732 break;
2733 }
2734
2735 ASSERT_NOT_REACHED();
2736 return VerticalAlign::Top;
2737}
2738
2739template<> inline CSSPrimitiveValue::CSSPrimitiveValue(Visibility e)
2740 : CSSValue(PrimitiveClass)
2741{
2742 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
2743 switch (e) {
2744 case Visibility::Visible:
2745 m_value.valueID = CSSValueVisible;
2746 break;
2747 case Visibility::Hidden:
2748 m_value.valueID = CSSValueHidden;
2749 break;
2750 case Visibility::Collapse:
2751 m_value.valueID = CSSValueCollapse;
2752 break;
2753 }
2754}
2755
2756template<> inline CSSPrimitiveValue::operator Visibility() const
2757{
2758 ASSERT(isValueID());
2759
2760 switch (m_value.valueID) {
2761 case CSSValueHidden:
2762 return Visibility::Hidden;
2763 case CSSValueVisible:
2764 return Visibility::Visible;
2765 case CSSValueCollapse:
2766 return Visibility::Collapse;
2767 default:
2768 break;
2769 }
2770
2771 ASSERT_NOT_REACHED();
2772 return Visibility::Visible;
2773}
2774
2775template<> inline CSSPrimitiveValue::CSSPrimitiveValue(WhiteSpace e)
2776 : CSSValue(PrimitiveClass)
2777{
2778 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
2779 switch (e) {
2780 case WhiteSpace::Normal:
2781 m_value.valueID = CSSValueNormal;
2782 break;
2783 case WhiteSpace::Pre:
2784 m_value.valueID = CSSValuePre;
2785 break;
2786 case WhiteSpace::PreWrap:
2787 m_value.valueID = CSSValuePreWrap;
2788 break;
2789 case WhiteSpace::PreLine:
2790 m_value.valueID = CSSValuePreLine;
2791 break;
2792 case WhiteSpace::NoWrap:
2793 m_value.valueID = CSSValueNowrap;
2794 break;
2795 case WhiteSpace::KHTMLNoWrap:
2796 m_value.valueID = CSSValueWebkitNowrap;
2797 break;
2798 case WhiteSpace::BreakSpaces:
2799 m_value.valueID = CSSValueBreakSpaces;
2800 break;
2801 }
2802}
2803
2804template<> inline CSSPrimitiveValue::operator WhiteSpace() const
2805{
2806 ASSERT(isValueID());
2807
2808 switch (m_value.valueID) {
2809 case CSSValueWebkitNowrap:
2810 return WhiteSpace::KHTMLNoWrap;
2811 case CSSValueNowrap:
2812 return WhiteSpace::NoWrap;
2813 case CSSValuePre:
2814 return WhiteSpace::Pre;
2815 case CSSValuePreWrap:
2816 return WhiteSpace::PreWrap;
2817 case CSSValuePreLine:
2818 return WhiteSpace::PreLine;
2819 case CSSValueNormal:
2820 return WhiteSpace::Normal;
2821 case CSSValueBreakSpaces:
2822 return WhiteSpace::BreakSpaces;
2823 default:
2824 break;
2825 }
2826
2827 ASSERT_NOT_REACHED();
2828 return WhiteSpace::Normal;
2829}
2830
2831template<> inline CSSPrimitiveValue::CSSPrimitiveValue(WordBreak e)
2832 : CSSValue(PrimitiveClass)
2833{
2834 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
2835 switch (e) {
2836 case WordBreak::Normal:
2837 m_value.valueID = CSSValueNormal;
2838 break;
2839 case WordBreak::BreakAll:
2840 m_value.valueID = CSSValueBreakAll;
2841 break;
2842 case WordBreak::KeepAll:
2843 m_value.valueID = CSSValueKeepAll;
2844 break;
2845 case WordBreak::BreakWord:
2846 m_value.valueID = CSSValueBreakWord;
2847 break;
2848 }
2849}
2850
2851template<> inline CSSPrimitiveValue::operator WordBreak() const
2852{
2853 ASSERT(isValueID());
2854
2855 switch (m_value.valueID) {
2856 case CSSValueBreakAll:
2857 return WordBreak::BreakAll;
2858 case CSSValueKeepAll:
2859 return WordBreak::KeepAll;
2860 case CSSValueBreakWord:
2861 return WordBreak::BreakWord;
2862 case CSSValueNormal:
2863 return WordBreak::Normal;
2864 default:
2865 break;
2866 }
2867
2868 ASSERT_NOT_REACHED();
2869 return WordBreak::Normal;
2870}
2871
2872template<> inline CSSPrimitiveValue::CSSPrimitiveValue(OverflowWrap e)
2873 : CSSValue(PrimitiveClass)
2874{
2875 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
2876 switch (e) {
2877 case OverflowWrap::Normal:
2878 m_value.valueID = CSSValueNormal;
2879 break;
2880 case OverflowWrap::Anywhere:
2881 m_value.valueID = CSSValueAnywhere;
2882 break;
2883 case OverflowWrap::BreakWord:
2884 m_value.valueID = CSSValueBreakWord;
2885 break;
2886 }
2887}
2888
2889template<> inline CSSPrimitiveValue::operator OverflowWrap() const
2890{
2891 ASSERT(isValueID());
2892
2893 switch (m_value.valueID) {
2894 case CSSValueBreakWord:
2895 return OverflowWrap::BreakWord;
2896 case CSSValueAnywhere:
2897 return OverflowWrap::Anywhere;
2898 case CSSValueNormal:
2899 return OverflowWrap::Normal;
2900 default:
2901 break;
2902 }
2903
2904 ASSERT_NOT_REACHED();
2905 return OverflowWrap::Normal;
2906}
2907
2908template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextDirection e)
2909 : CSSValue(PrimitiveClass)
2910{
2911 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
2912 switch (e) {
2913 case TextDirection::LTR:
2914 m_value.valueID = CSSValueLtr;
2915 break;
2916 case TextDirection::RTL:
2917 m_value.valueID = CSSValueRtl;
2918 break;
2919 }
2920}
2921
2922template<> inline CSSPrimitiveValue::operator TextDirection() const
2923{
2924 ASSERT(isValueID());
2925
2926 switch (m_value.valueID) {
2927 case CSSValueLtr:
2928 return TextDirection::LTR;
2929 case CSSValueRtl:
2930 return TextDirection::RTL;
2931 default:
2932 break;
2933 }
2934
2935 ASSERT_NOT_REACHED();
2936 return TextDirection::LTR;
2937}
2938
2939template<> inline CSSPrimitiveValue::CSSPrimitiveValue(WritingMode e)
2940 : CSSValue(PrimitiveClass)
2941{
2942 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
2943 switch (e) {
2944 case WritingMode::TopToBottom:
2945 m_value.valueID = CSSValueHorizontalTb;
2946 break;
2947 case WritingMode::RightToLeft:
2948 m_value.valueID = CSSValueVerticalRl;
2949 break;
2950 case WritingMode::LeftToRight:
2951 m_value.valueID = CSSValueVerticalLr;
2952 break;
2953 case WritingMode::BottomToTop:
2954 m_value.valueID = CSSValueHorizontalBt;
2955 break;
2956 }
2957}
2958
2959template<> inline CSSPrimitiveValue::operator WritingMode() const
2960{
2961 ASSERT(isValueID());
2962
2963 switch (m_value.valueID) {
2964 case CSSValueHorizontalTb:
2965 case CSSValueLr:
2966 case CSSValueLrTb:
2967 case CSSValueRl:
2968 case CSSValueRlTb:
2969 return WritingMode::TopToBottom;
2970 case CSSValueVerticalRl:
2971 case CSSValueTb:
2972 case CSSValueTbRl:
2973 return WritingMode::RightToLeft;
2974 case CSSValueVerticalLr:
2975 return WritingMode::LeftToRight;
2976 case CSSValueHorizontalBt:
2977 return WritingMode::BottomToTop;
2978 default:
2979 break;
2980 }
2981
2982 ASSERT_NOT_REACHED();
2983 return WritingMode::TopToBottom;
2984}
2985
2986template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextCombine e)
2987 : CSSValue(PrimitiveClass)
2988{
2989 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
2990 switch (e) {
2991 case TextCombine::None:
2992 m_value.valueID = CSSValueNone;
2993 break;
2994 case TextCombine::All:
2995 m_value.valueID = CSSValueAll;
2996 break;
2997 }
2998}
2999
3000template<> inline CSSPrimitiveValue::operator TextCombine() const
3001{
3002 ASSERT(isValueID());
3003
3004 switch (m_value.valueID) {
3005 case CSSValueNone:
3006 return TextCombine::None;
3007 case CSSValueAll:
3008 case CSSValueHorizontal: // -webkit-text-combine only
3009 return TextCombine::All;
3010 default:
3011 break;
3012 }
3013
3014 ASSERT_NOT_REACHED();
3015 return TextCombine::None;
3016}
3017
3018template<> inline CSSPrimitiveValue::CSSPrimitiveValue(RubyPosition position)
3019 : CSSValue(PrimitiveClass)
3020{
3021 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
3022 switch (position) {
3023 case RubyPosition::Before:
3024 m_value.valueID = CSSValueBefore;
3025 break;
3026 case RubyPosition::After:
3027 m_value.valueID = CSSValueAfter;
3028 break;
3029 case RubyPosition::InterCharacter:
3030 m_value.valueID = CSSValueInterCharacter;
3031 break;
3032 }
3033}
3034
3035template<> inline CSSPrimitiveValue::operator RubyPosition() const
3036{
3037 ASSERT(isValueID());
3038
3039 switch (m_value.valueID) {
3040 case CSSValueBefore:
3041 return RubyPosition::Before;
3042 case CSSValueAfter:
3043 return RubyPosition::After;
3044 case CSSValueInterCharacter:
3045 return RubyPosition::InterCharacter;
3046 default:
3047 break;
3048 }
3049
3050 ASSERT_NOT_REACHED();
3051 return RubyPosition::Before;
3052}
3053
3054template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextOverflow overflow)
3055 : CSSValue(PrimitiveClass)
3056{
3057 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
3058 switch (overflow) {
3059 case TextOverflow::Clip:
3060 m_value.valueID = CSSValueClip;
3061 break;
3062 case TextOverflow::Ellipsis:
3063 m_value.valueID = CSSValueEllipsis;
3064 break;
3065 }
3066}
3067
3068template<> inline CSSPrimitiveValue::operator TextOverflow() const
3069{
3070 ASSERT(isValueID());
3071
3072 switch (m_value.valueID) {
3073 case CSSValueClip:
3074 return TextOverflow::Clip;
3075 case CSSValueEllipsis:
3076 return TextOverflow::Ellipsis;
3077 default:
3078 break;
3079 }
3080
3081 ASSERT_NOT_REACHED();
3082 return TextOverflow::Clip;
3083}
3084
3085template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextEmphasisFill fill)
3086 : CSSValue(PrimitiveClass)
3087{
3088 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
3089 switch (fill) {
3090 case TextEmphasisFill::Filled:
3091 m_value.valueID = CSSValueFilled;
3092 break;
3093 case TextEmphasisFill::Open:
3094 m_value.valueID = CSSValueOpen;
3095 break;
3096 }
3097}
3098
3099template<> inline CSSPrimitiveValue::operator TextEmphasisFill() const
3100{
3101 ASSERT(isValueID());
3102
3103 switch (m_value.valueID) {
3104 case CSSValueFilled:
3105 return TextEmphasisFill::Filled;
3106 case CSSValueOpen:
3107 return TextEmphasisFill::Open;
3108 default:
3109 break;
3110 }
3111
3112 ASSERT_NOT_REACHED();
3113 return TextEmphasisFill::Filled;
3114}
3115
3116template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextEmphasisMark mark)
3117 : CSSValue(PrimitiveClass)
3118{
3119 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
3120 switch (mark) {
3121 case TextEmphasisMark::Dot:
3122 m_value.valueID = CSSValueDot;
3123 break;
3124 case TextEmphasisMark::Circle:
3125 m_value.valueID = CSSValueCircle;
3126 break;
3127 case TextEmphasisMark::DoubleCircle:
3128 m_value.valueID = CSSValueDoubleCircle;
3129 break;
3130 case TextEmphasisMark::Triangle:
3131 m_value.valueID = CSSValueTriangle;
3132 break;
3133 case TextEmphasisMark::Sesame:
3134 m_value.valueID = CSSValueSesame;
3135 break;
3136 case TextEmphasisMark::None:
3137 case TextEmphasisMark::Auto:
3138 case TextEmphasisMark::Custom:
3139 ASSERT_NOT_REACHED();
3140 m_value.valueID = CSSValueNone;
3141 break;
3142 }
3143}
3144
3145template<> inline CSSPrimitiveValue::operator TextEmphasisMark() const
3146{
3147 ASSERT(isValueID());
3148
3149 switch (m_value.valueID) {
3150 case CSSValueNone:
3151 return TextEmphasisMark::None;
3152 case CSSValueDot:
3153 return TextEmphasisMark::Dot;
3154 case CSSValueCircle:
3155 return TextEmphasisMark::Circle;
3156 case CSSValueDoubleCircle:
3157 return TextEmphasisMark::DoubleCircle;
3158 case CSSValueTriangle:
3159 return TextEmphasisMark::Triangle;
3160 case CSSValueSesame:
3161 return TextEmphasisMark::Sesame;
3162 default:
3163 break;
3164 }
3165
3166 ASSERT_NOT_REACHED();
3167 return TextEmphasisMark::None;
3168}
3169
3170template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextOrientation e)
3171 : CSSValue(PrimitiveClass)
3172{
3173 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
3174 switch (e) {
3175 case TextOrientation::Sideways:
3176 m_value.valueID = CSSValueSideways;
3177 break;
3178 case TextOrientation::Mixed:
3179 m_value.valueID = CSSValueMixed;
3180 break;
3181 case TextOrientation::Upright:
3182 m_value.valueID = CSSValueUpright;
3183 break;
3184 }
3185}
3186
3187template<> inline CSSPrimitiveValue::operator TextOrientation() const
3188{
3189 ASSERT(isValueID());
3190
3191 switch (m_value.valueID) {
3192 case CSSValueSideways:
3193 return TextOrientation::Sideways;
3194 case CSSValueMixed:
3195 return TextOrientation::Mixed;
3196 case CSSValueUpright:
3197 return TextOrientation::Upright;
3198 default:
3199 break;
3200 }
3201
3202 ASSERT_NOT_REACHED();
3203 return TextOrientation::Mixed;
3204}
3205
3206template<> inline CSSPrimitiveValue::CSSPrimitiveValue(PointerEvents e)
3207 : CSSValue(PrimitiveClass)
3208{
3209 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
3210 switch (e) {
3211 case PointerEvents::None:
3212 m_value.valueID = CSSValueNone;
3213 break;
3214 case PointerEvents::Stroke:
3215 m_value.valueID = CSSValueStroke;
3216 break;
3217 case PointerEvents::Fill:
3218 m_value.valueID = CSSValueFill;
3219 break;
3220 case PointerEvents::Painted:
3221 m_value.valueID = CSSValuePainted;
3222 break;
3223 case PointerEvents::Visible:
3224 m_value.valueID = CSSValueVisible;
3225 break;
3226 case PointerEvents::VisibleStroke:
3227 m_value.valueID = CSSValueVisibleStroke;
3228 break;
3229 case PointerEvents::VisibleFill:
3230 m_value.valueID = CSSValueVisibleFill;
3231 break;
3232 case PointerEvents::VisiblePainted:
3233 m_value.valueID = CSSValueVisiblePainted;
3234 break;
3235 case PointerEvents::BoundingBox:
3236 m_value.valueID = CSSValueBoundingBox;
3237 break;
3238 case PointerEvents::Auto:
3239 m_value.valueID = CSSValueAuto;
3240 break;
3241 case PointerEvents::All:
3242 m_value.valueID = CSSValueAll;
3243 break;
3244 }
3245}
3246
3247template<> inline CSSPrimitiveValue::operator PointerEvents() const
3248{
3249 ASSERT(isValueID());
3250
3251 switch (m_value.valueID) {
3252 case CSSValueAll:
3253 return PointerEvents::All;
3254 case CSSValueAuto:
3255 return PointerEvents::Auto;
3256 case CSSValueNone:
3257 return PointerEvents::None;
3258 case CSSValueVisiblePainted:
3259 return PointerEvents::VisiblePainted;
3260 case CSSValueVisibleFill:
3261 return PointerEvents::VisibleFill;
3262 case CSSValueVisibleStroke:
3263 return PointerEvents::VisibleStroke;
3264 case CSSValueVisible:
3265 return PointerEvents::Visible;
3266 case CSSValuePainted:
3267 return PointerEvents::Painted;
3268 case CSSValueFill:
3269 return PointerEvents::Fill;
3270 case CSSValueStroke:
3271 return PointerEvents::Stroke;
3272 case CSSValueBoundingBox:
3273 return PointerEvents::BoundingBox;
3274 default:
3275 break;
3276 }
3277
3278 ASSERT_NOT_REACHED();
3279 return PointerEvents::All;
3280}
3281
3282template<> inline CSSPrimitiveValue::CSSPrimitiveValue(Kerning kerning)
3283 : CSSValue(PrimitiveClass)
3284{
3285 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
3286 switch (kerning) {
3287 case Kerning::Auto:
3288 m_value.valueID = CSSValueAuto;
3289 return;
3290 case Kerning::Normal:
3291 m_value.valueID = CSSValueNormal;
3292 return;
3293 case Kerning::NoShift:
3294 m_value.valueID = CSSValueNone;
3295 return;
3296 }
3297
3298 ASSERT_NOT_REACHED();
3299 m_value.valueID = CSSValueAuto;
3300}
3301
3302template<> inline CSSPrimitiveValue::operator Kerning() const
3303{
3304 ASSERT(isValueID());
3305
3306 switch (m_value.valueID) {
3307 case CSSValueAuto:
3308 return Kerning::Auto;
3309 case CSSValueNormal:
3310 return Kerning::Normal;
3311 case CSSValueNone:
3312 return Kerning::NoShift;
3313 default:
3314 break;
3315 }
3316
3317 ASSERT_NOT_REACHED();
3318 return Kerning::Auto;
3319}
3320
3321template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ObjectFit fit)
3322 : CSSValue(PrimitiveClass)
3323{
3324 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
3325 switch (fit) {
3326 case ObjectFit::Fill:
3327 m_value.valueID = CSSValueFill;
3328 break;
3329 case ObjectFit::Contain:
3330 m_value.valueID = CSSValueContain;
3331 break;
3332 case ObjectFit::Cover:
3333 m_value.valueID = CSSValueCover;
3334 break;
3335 case ObjectFit::None:
3336 m_value.valueID = CSSValueNone;
3337 break;
3338 case ObjectFit::ScaleDown:
3339 m_value.valueID = CSSValueScaleDown;
3340 break;
3341 }
3342}
3343
3344template<> inline CSSPrimitiveValue::operator ObjectFit() const
3345{
3346 ASSERT(isValueID());
3347
3348 switch (m_value.valueID) {
3349 case CSSValueFill:
3350 return ObjectFit::Fill;
3351 case CSSValueContain:
3352 return ObjectFit::Contain;
3353 case CSSValueCover:
3354 return ObjectFit::Cover;
3355 case CSSValueNone:
3356 return ObjectFit::None;
3357 case CSSValueScaleDown:
3358 return ObjectFit::ScaleDown;
3359 default:
3360 ASSERT_NOT_REACHED();
3361 return ObjectFit::Fill;
3362 }
3363}
3364
3365template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontSmoothingMode smoothing)
3366 : CSSValue(PrimitiveClass)
3367{
3368 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
3369 switch (smoothing) {
3370 case FontSmoothingMode::AutoSmoothing:
3371 m_value.valueID = CSSValueAuto;
3372 return;
3373 case FontSmoothingMode::NoSmoothing:
3374 m_value.valueID = CSSValueNone;
3375 return;
3376 case FontSmoothingMode::Antialiased:
3377 m_value.valueID = CSSValueAntialiased;
3378 return;
3379 case FontSmoothingMode::SubpixelAntialiased:
3380 m_value.valueID = CSSValueSubpixelAntialiased;
3381 return;
3382 }
3383
3384 ASSERT_NOT_REACHED();
3385 m_value.valueID = CSSValueAuto;
3386}
3387
3388template<> inline CSSPrimitiveValue::operator FontSmoothingMode() const
3389{
3390 ASSERT(isValueID());
3391
3392 switch (m_value.valueID) {
3393 case CSSValueAuto:
3394 return FontSmoothingMode::AutoSmoothing;
3395 case CSSValueNone:
3396 return FontSmoothingMode::NoSmoothing;
3397 case CSSValueAntialiased:
3398 return FontSmoothingMode::Antialiased;
3399 case CSSValueSubpixelAntialiased:
3400 return FontSmoothingMode::SubpixelAntialiased;
3401 default:
3402 break;
3403 }
3404
3405 ASSERT_NOT_REACHED();
3406 return FontSmoothingMode::AutoSmoothing;
3407}
3408
3409template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontSmallCaps smallCaps)
3410 : CSSValue(PrimitiveClass)
3411{
3412 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
3413 switch (smallCaps) {
3414 case FontSmallCaps::Off:
3415 m_value.valueID = CSSValueNormal;
3416 return;
3417 case FontSmallCaps::On:
3418 m_value.valueID = CSSValueSmallCaps;
3419 return;
3420 }
3421
3422 ASSERT_NOT_REACHED();
3423 m_value.valueID = CSSValueNormal;
3424}
3425
3426template<> inline CSSPrimitiveValue::operator FontSmallCaps() const
3427{
3428 ASSERT(isValueID());
3429
3430 switch (m_value.valueID) {
3431 case CSSValueSmallCaps:
3432 return FontSmallCaps::On;
3433 case CSSValueNormal:
3434 return FontSmallCaps::Off;
3435 default:
3436 break;
3437 }
3438 ASSERT_NOT_REACHED();
3439 return FontSmallCaps::Off;
3440}
3441
3442template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextRenderingMode e)
3443 : CSSValue(PrimitiveClass)
3444{
3445 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
3446 switch (e) {
3447 case TextRenderingMode::AutoTextRendering:
3448 m_value.valueID = CSSValueAuto;
3449 break;
3450 case TextRenderingMode::OptimizeSpeed:
3451 m_value.valueID = CSSValueOptimizeSpeed;
3452 break;
3453 case TextRenderingMode::OptimizeLegibility:
3454 m_value.valueID = CSSValueOptimizeLegibility;
3455 break;
3456 case TextRenderingMode::GeometricPrecision:
3457 m_value.valueID = CSSValueGeometricPrecision;
3458 break;
3459 }
3460}
3461
3462template<> inline CSSPrimitiveValue::operator TextRenderingMode() const
3463{
3464 ASSERT(isValueID());
3465
3466 switch (m_value.valueID) {
3467 case CSSValueAuto:
3468 return TextRenderingMode::AutoTextRendering;
3469 case CSSValueOptimizeSpeed:
3470 return TextRenderingMode::OptimizeSpeed;
3471 case CSSValueOptimizeLegibility:
3472 return TextRenderingMode::OptimizeLegibility;
3473 case CSSValueGeometricPrecision:
3474 return TextRenderingMode::GeometricPrecision;
3475 default:
3476 break;
3477 }
3478
3479 ASSERT_NOT_REACHED();
3480 return TextRenderingMode::AutoTextRendering;
3481}
3482
3483template<> inline CSSPrimitiveValue::CSSPrimitiveValue(Hyphens hyphens)
3484 : CSSValue(PrimitiveClass)
3485{
3486 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
3487 switch (hyphens) {
3488 case Hyphens::None:
3489 m_value.valueID = CSSValueNone;
3490 break;
3491 case Hyphens::Manual:
3492 m_value.valueID = CSSValueManual;
3493 break;
3494 case Hyphens::Auto:
3495 m_value.valueID = CSSValueAuto;
3496 break;
3497 }
3498}
3499
3500template<> inline CSSPrimitiveValue::operator Hyphens() const
3501{
3502 ASSERT(isValueID());
3503
3504 switch (m_value.valueID) {
3505 case CSSValueNone:
3506 return Hyphens::None;
3507 case CSSValueManual:
3508 return Hyphens::Manual;
3509 case CSSValueAuto:
3510 return Hyphens::Auto;
3511 default:
3512 break;
3513 }
3514
3515 ASSERT_NOT_REACHED();
3516 return Hyphens::Auto;
3517}
3518
3519template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineSnap gridSnap)
3520 : CSSValue(PrimitiveClass)
3521{
3522 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
3523 switch (gridSnap) {
3524 case LineSnap::None:
3525 m_value.valueID = CSSValueNone;
3526 break;
3527 case LineSnap::Baseline:
3528 m_value.valueID = CSSValueBaseline;
3529 break;
3530 case LineSnap::Contain:
3531 m_value.valueID = CSSValueContain;
3532 break;
3533 }
3534}
3535
3536template<> inline CSSPrimitiveValue::operator LineSnap() const
3537{
3538 ASSERT(isValueID());
3539
3540 switch (m_value.valueID) {
3541 case CSSValueNone:
3542 return LineSnap::None;
3543 case CSSValueBaseline:
3544 return LineSnap::Baseline;
3545 case CSSValueContain:
3546 return LineSnap::Contain;
3547 default:
3548 break;
3549 }
3550
3551 ASSERT_NOT_REACHED();
3552 return LineSnap::None;
3553}
3554
3555template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineAlign lineAlign)
3556 : CSSValue(PrimitiveClass)
3557{
3558 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
3559 switch (lineAlign) {
3560 case LineAlign::None:
3561 m_value.valueID = CSSValueNone;
3562 break;
3563 case LineAlign::Edges:
3564 m_value.valueID = CSSValueEdges;
3565 break;
3566 }
3567}
3568
3569template<> inline CSSPrimitiveValue::operator LineAlign() const
3570{
3571 ASSERT(isValueID());
3572
3573 switch (m_value.valueID) {
3574 case CSSValueNone:
3575 return LineAlign::None;
3576 case CSSValueEdges:
3577 return LineAlign::Edges;
3578 default:
3579 break;
3580 }
3581
3582 ASSERT_NOT_REACHED();
3583 return LineAlign::None;
3584}
3585
3586template<> inline CSSPrimitiveValue::CSSPrimitiveValue(SpeakAs e)
3587 : CSSValue(PrimitiveClass)
3588{
3589 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
3590 switch (e) {
3591 case SpeakAs::Normal:
3592 m_value.valueID = CSSValueNormal;
3593 break;
3594 case SpeakAs::SpellOut:
3595 m_value.valueID = CSSValueSpellOut;
3596 break;
3597 case SpeakAs::Digits:
3598 m_value.valueID = CSSValueDigits;
3599 break;
3600 case SpeakAs::LiteralPunctuation:
3601 m_value.valueID = CSSValueLiteralPunctuation;
3602 break;
3603 case SpeakAs::NoPunctuation:
3604 m_value.valueID = CSSValueNoPunctuation;
3605 break;
3606 }
3607}
3608
3609template<> inline CSSPrimitiveValue::operator Order() const
3610{
3611 ASSERT(isValueID());
3612
3613 switch (m_value.valueID) {
3614 case CSSValueLogical:
3615 return Order::Logical;
3616 case CSSValueVisual:
3617 return Order::Visual;
3618 default:
3619 break;
3620 }
3621
3622 ASSERT_NOT_REACHED();
3623 return Order::Logical;
3624}
3625
3626template<> inline CSSPrimitiveValue::CSSPrimitiveValue(Order e)
3627 : CSSValue(PrimitiveClass)
3628{
3629 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
3630 switch (e) {
3631 case Order::Logical:
3632 m_value.valueID = CSSValueLogical;
3633 break;
3634 case Order::Visual:
3635 m_value.valueID = CSSValueVisual;
3636 break;
3637 }
3638}
3639
3640template<> inline CSSPrimitiveValue::operator OptionSet<SpeakAs>() const
3641{
3642 ASSERT(isValueID());
3643
3644 switch (m_value.valueID) {
3645 case CSSValueNormal:
3646 return OptionSet<SpeakAs> { };
3647 case CSSValueSpellOut:
3648 return SpeakAs::SpellOut;
3649 case CSSValueDigits:
3650 return SpeakAs::Digits;
3651 case CSSValueLiteralPunctuation:
3652 return SpeakAs::LiteralPunctuation;
3653 case CSSValueNoPunctuation:
3654 return SpeakAs::NoPunctuation;
3655 default:
3656 break;
3657 }
3658
3659 ASSERT_NOT_REACHED();
3660 return OptionSet<SpeakAs> { };
3661}
3662
3663template<> inline CSSPrimitiveValue::CSSPrimitiveValue(BlendMode blendMode)
3664 : CSSValue(PrimitiveClass)
3665{
3666 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
3667 switch (blendMode) {
3668 case BlendMode::Normal:
3669 m_value.valueID = CSSValueNormal;
3670 break;
3671 case BlendMode::Multiply:
3672 m_value.valueID = CSSValueMultiply;
3673 break;
3674 case BlendMode::Screen:
3675 m_value.valueID = CSSValueScreen;
3676 break;
3677 case BlendMode::Overlay:
3678 m_value.valueID = CSSValueOverlay;
3679 break;
3680 case BlendMode::Darken:
3681 m_value.valueID = CSSValueDarken;
3682 break;
3683 case BlendMode::Lighten:
3684 m_value.valueID = CSSValueLighten;
3685 break;
3686 case BlendMode::ColorDodge:
3687 m_value.valueID = CSSValueColorDodge;
3688 break;
3689 case BlendMode::ColorBurn:
3690 m_value.valueID = CSSValueColorBurn;
3691 break;
3692 case BlendMode::HardLight:
3693 m_value.valueID = CSSValueHardLight;
3694 break;
3695 case BlendMode::SoftLight:
3696 m_value.valueID = CSSValueSoftLight;
3697 break;
3698 case BlendMode::Difference:
3699 m_value.valueID = CSSValueDifference;
3700 break;
3701 case BlendMode::Exclusion:
3702 m_value.valueID = CSSValueExclusion;
3703 break;
3704 case BlendMode::Hue:
3705 m_value.valueID = CSSValueHue;
3706 break;
3707 case BlendMode::Saturation:
3708 m_value.valueID = CSSValueSaturation;
3709 break;
3710 case BlendMode::Color:
3711 m_value.valueID = CSSValueColor;
3712 break;
3713 case BlendMode::Luminosity:
3714 m_value.valueID = CSSValueLuminosity;
3715 break;
3716 case BlendMode::PlusDarker:
3717 m_value.valueID = CSSValuePlusDarker;
3718 break;
3719 case BlendMode::PlusLighter:
3720 m_value.valueID = CSSValuePlusLighter;
3721 break;
3722 }
3723}
3724
3725template<> inline CSSPrimitiveValue::operator BlendMode() const
3726{
3727 ASSERT(isValueID());
3728
3729 switch (m_value.valueID) {
3730 case CSSValueNormal:
3731 return BlendMode::Normal;
3732 case CSSValueMultiply:
3733 return BlendMode::Multiply;
3734 case CSSValueScreen:
3735 return BlendMode::Screen;
3736 case CSSValueOverlay:
3737 return BlendMode::Overlay;
3738 case CSSValueDarken:
3739 return BlendMode::Darken;
3740 case CSSValueLighten:
3741 return BlendMode::Lighten;
3742 case CSSValueColorDodge:
3743 return BlendMode::ColorDodge;
3744 case CSSValueColorBurn:
3745 return BlendMode::ColorBurn;
3746 case CSSValueHardLight:
3747 return BlendMode::HardLight;
3748 case CSSValueSoftLight:
3749 return BlendMode::SoftLight;
3750 case CSSValueDifference:
3751 return BlendMode::Difference;
3752 case CSSValueExclusion:
3753 return BlendMode::Exclusion;
3754 case CSSValueHue:
3755 return BlendMode::Hue;
3756 case CSSValueSaturation:
3757 return BlendMode::Saturation;
3758 case CSSValueColor:
3759 return BlendMode::Color;
3760 case CSSValueLuminosity:
3761 return BlendMode::Luminosity;
3762 case CSSValuePlusDarker:
3763 return BlendMode::PlusDarker;
3764 case CSSValuePlusLighter:
3765 return BlendMode::PlusLighter;
3766 default:
3767 break;
3768 }
3769
3770 ASSERT_NOT_REACHED();
3771 return BlendMode::Normal;
3772}
3773
3774template<> inline CSSPrimitiveValue::CSSPrimitiveValue(Isolation isolation)
3775 : CSSValue(PrimitiveClass)
3776{
3777 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
3778 switch (isolation) {
3779 case Isolation::Auto:
3780 m_value.valueID = CSSValueAuto;
3781 break;
3782 case Isolation::Isolate:
3783 m_value.valueID = CSSValueIsolate;
3784 break;
3785 default:
3786 ASSERT_NOT_REACHED();
3787 }
3788}
3789
3790template<> inline CSSPrimitiveValue::operator Isolation() const
3791{
3792 ASSERT(isValueID());
3793 switch (m_value.valueID) {
3794 case CSSValueAuto:
3795 return Isolation::Auto;
3796 case CSSValueIsolate:
3797 return Isolation::Isolate;
3798 default:
3799 break;
3800 }
3801
3802 ASSERT_NOT_REACHED();
3803 return Isolation::Auto;
3804}
3805
3806template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineCap e)
3807 : CSSValue(PrimitiveClass)
3808{
3809 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
3810 switch (e) {
3811 case LineCap::Butt:
3812 m_value.valueID = CSSValueButt;
3813 break;
3814 case LineCap::Round:
3815 m_value.valueID = CSSValueRound;
3816 break;
3817 case LineCap::Square:
3818 m_value.valueID = CSSValueSquare;
3819 break;
3820 }
3821}
3822
3823template<> inline CSSPrimitiveValue::operator LineCap() const
3824{
3825 ASSERT(isValueID());
3826
3827 switch (m_value.valueID) {
3828 case CSSValueButt:
3829 return LineCap::Butt;
3830 case CSSValueRound:
3831 return LineCap::Round;
3832 case CSSValueSquare:
3833 return LineCap::Square;
3834 default:
3835 break;
3836 }
3837
3838 ASSERT_NOT_REACHED();
3839 return LineCap::Butt;
3840}
3841
3842template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineJoin e)
3843 : CSSValue(PrimitiveClass)
3844{
3845 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
3846 switch (e) {
3847 case LineJoin::Miter:
3848 m_value.valueID = CSSValueMiter;
3849 break;
3850 case LineJoin::Round:
3851 m_value.valueID = CSSValueRound;
3852 break;
3853 case LineJoin::Bevel:
3854 m_value.valueID = CSSValueBevel;
3855 break;
3856 }
3857}
3858
3859template<> inline CSSPrimitiveValue::operator LineJoin() const
3860{
3861 ASSERT(isValueID());
3862
3863 switch (m_value.valueID) {
3864 case CSSValueMiter:
3865 return LineJoin::Miter;
3866 case CSSValueRound:
3867 return LineJoin::Round;
3868 case CSSValueBevel:
3869 return LineJoin::Bevel;
3870 default:
3871 break;
3872 }
3873
3874 ASSERT_NOT_REACHED();
3875 return LineJoin::Miter;
3876}
3877
3878template<> inline CSSPrimitiveValue::CSSPrimitiveValue(WindRule e)
3879 : CSSValue(PrimitiveClass)
3880{
3881 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
3882 switch (e) {
3883 case WindRule::NonZero:
3884 m_value.valueID = CSSValueNonzero;
3885 break;
3886 case WindRule::EvenOdd:
3887 m_value.valueID = CSSValueEvenodd;
3888 break;
3889 }
3890}
3891
3892template<> inline CSSPrimitiveValue::operator WindRule() const
3893{
3894 ASSERT(isValueID());
3895
3896 switch (m_value.valueID) {
3897 case CSSValueNonzero:
3898 return WindRule::NonZero;
3899 case CSSValueEvenodd:
3900 return WindRule::EvenOdd;
3901 default:
3902 break;
3903 }
3904
3905 ASSERT_NOT_REACHED();
3906 return WindRule::NonZero;
3907}
3908
3909
3910template<> inline CSSPrimitiveValue::CSSPrimitiveValue(AlignmentBaseline e)
3911 : CSSValue(PrimitiveClass)
3912{
3913 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
3914 switch (e) {
3915 case AlignmentBaseline::Auto:
3916 m_value.valueID = CSSValueAuto;
3917 break;
3918 case AlignmentBaseline::Baseline:
3919 m_value.valueID = CSSValueBaseline;
3920 break;
3921 case AlignmentBaseline::BeforeEdge:
3922 m_value.valueID = CSSValueBeforeEdge;
3923 break;
3924 case AlignmentBaseline::TextBeforeEdge:
3925 m_value.valueID = CSSValueTextBeforeEdge;
3926 break;
3927 case AlignmentBaseline::Middle:
3928 m_value.valueID = CSSValueMiddle;
3929 break;
3930 case AlignmentBaseline::Central:
3931 m_value.valueID = CSSValueCentral;
3932 break;
3933 case AlignmentBaseline::AfterEdge:
3934 m_value.valueID = CSSValueAfterEdge;
3935 break;
3936 case AlignmentBaseline::TextAfterEdge:
3937 m_value.valueID = CSSValueTextAfterEdge;
3938 break;
3939 case AlignmentBaseline::Ideographic:
3940 m_value.valueID = CSSValueIdeographic;
3941 break;
3942 case AlignmentBaseline::Alphabetic:
3943 m_value.valueID = CSSValueAlphabetic;
3944 break;
3945 case AlignmentBaseline::Hanging:
3946 m_value.valueID = CSSValueHanging;
3947 break;
3948 case AlignmentBaseline::Mathematical:
3949 m_value.valueID = CSSValueMathematical;
3950 break;
3951 }
3952}
3953
3954template<> inline CSSPrimitiveValue::operator AlignmentBaseline() const
3955{
3956 ASSERT(isValueID());
3957
3958 switch (m_value.valueID) {
3959 case CSSValueAuto:
3960 return AlignmentBaseline::Auto;
3961 case CSSValueBaseline:
3962 return AlignmentBaseline::Baseline;
3963 case CSSValueBeforeEdge:
3964 return AlignmentBaseline::BeforeEdge;
3965 case CSSValueTextBeforeEdge:
3966 return AlignmentBaseline::TextBeforeEdge;
3967 case CSSValueMiddle:
3968 return AlignmentBaseline::Middle;
3969 case CSSValueCentral:
3970 return AlignmentBaseline::Central;
3971 case CSSValueAfterEdge:
3972 return AlignmentBaseline::AfterEdge;
3973 case CSSValueTextAfterEdge:
3974 return AlignmentBaseline::TextAfterEdge;
3975 case CSSValueIdeographic:
3976 return AlignmentBaseline::Ideographic;
3977 case CSSValueAlphabetic:
3978 return AlignmentBaseline::Alphabetic;
3979 case CSSValueHanging:
3980 return AlignmentBaseline::Hanging;
3981 case CSSValueMathematical:
3982 return AlignmentBaseline::Mathematical;
3983 default:
3984 break;
3985 }
3986
3987 ASSERT_NOT_REACHED();
3988 return AlignmentBaseline::Auto;
3989}
3990
3991template<> inline CSSPrimitiveValue::CSSPrimitiveValue(BorderCollapse e)
3992 : CSSValue(PrimitiveClass)
3993{
3994 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
3995 switch (e) {
3996 case BorderCollapse::Separate:
3997 m_value.valueID = CSSValueSeparate;
3998 break;
3999 case BorderCollapse::Collapse:
4000 m_value.valueID = CSSValueCollapse;
4001 break;
4002 }
4003}
4004
4005template<> inline CSSPrimitiveValue::operator BorderCollapse() const
4006{
4007 ASSERT(isValueID());
4008
4009 switch (m_value.valueID) {
4010 case CSSValueSeparate:
4011 return BorderCollapse::Separate;
4012 case CSSValueCollapse:
4013 return BorderCollapse::Collapse;
4014 default:
4015 break;
4016 }
4017
4018 ASSERT_NOT_REACHED();
4019 return BorderCollapse::Separate;
4020}
4021
4022template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ImageRendering imageRendering)
4023 : CSSValue(PrimitiveClass)
4024{
4025 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
4026 switch (imageRendering) {
4027 case ImageRendering::Auto:
4028 m_value.valueID = CSSValueAuto;
4029 break;
4030 case ImageRendering::CrispEdges:
4031 m_value.valueID = CSSValueCrispEdges;
4032 break;
4033 case ImageRendering::Pixelated:
4034 m_value.valueID = CSSValuePixelated;
4035 break;
4036 case ImageRendering::OptimizeSpeed:
4037 m_value.valueID = CSSValueOptimizeSpeed;
4038 break;
4039 case ImageRendering::OptimizeQuality:
4040 m_value.valueID = CSSValueOptimizeQuality;
4041 break;
4042 }
4043}
4044
4045template<> inline CSSPrimitiveValue::operator ImageRendering() const
4046{
4047 ASSERT(isValueID());
4048
4049 switch (m_value.valueID) {
4050 case CSSValueAuto:
4051 return ImageRendering::Auto;
4052 case CSSValueWebkitOptimizeContrast:
4053 case CSSValueCrispEdges:
4054 case CSSValueWebkitCrispEdges:
4055 return ImageRendering::CrispEdges;
4056 case CSSValuePixelated:
4057 return ImageRendering::Pixelated;
4058 case CSSValueOptimizeSpeed:
4059 return ImageRendering::OptimizeSpeed;
4060 case CSSValueOptimizeQuality:
4061 return ImageRendering::OptimizeQuality;
4062 default:
4063 break;
4064 }
4065
4066 ASSERT_NOT_REACHED();
4067 return ImageRendering::Auto;
4068}
4069
4070template<> inline CSSPrimitiveValue::CSSPrimitiveValue(InputSecurity e)
4071 : CSSValue(PrimitiveClass)
4072{
4073 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
4074 switch (e) {
4075 case InputSecurity::Auto:
4076 m_value.valueID = CSSValueAuto;
4077 break;
4078 case InputSecurity::None:
4079 m_value.valueID = CSSValueNone;
4080 break;
4081 }
4082}
4083
4084template<> inline CSSPrimitiveValue::operator InputSecurity() const
4085{
4086 ASSERT(isValueID());
4087
4088 switch (m_value.valueID) {
4089 case CSSValueAuto:
4090 return InputSecurity::Auto;
4091 case CSSValueNone:
4092 return InputSecurity::None;
4093 default:
4094 break;
4095 }
4096
4097 ASSERT_NOT_REACHED();
4098 return InputSecurity::Auto;
4099}
4100
4101template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TransformStyle3D e)
4102 : CSSValue(PrimitiveClass)
4103{
4104 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
4105 switch (e) {
4106 case TransformStyle3D::Flat:
4107 m_value.valueID = CSSValueFlat;
4108 break;
4109 case TransformStyle3D::Preserve3D:
4110 m_value.valueID = CSSValuePreserve3d;
4111 break;
4112#if ENABLE(CSS_TRANSFORM_STYLE_OPTIMIZED_3D)
4113 case TransformStyle3D::Optimized3D:
4114 m_value.valueID = CSSValueOptimized3d;
4115 break;
4116#endif
4117 }
4118}
4119
4120template<> inline CSSPrimitiveValue::operator TransformStyle3D() const
4121{
4122 ASSERT(isValueID());
4123
4124 switch (m_value.valueID) {
4125 case CSSValueFlat:
4126 return TransformStyle3D::Flat;
4127 case CSSValuePreserve3d:
4128 return TransformStyle3D::Preserve3D;
4129#if ENABLE(CSS_TRANSFORM_STYLE_OPTIMIZED_3D)
4130 case CSSValueOptimized3d:
4131 return TransformStyle3D::Optimized3D;
4132#endif
4133 default:
4134 break;
4135 }
4136
4137 ASSERT_NOT_REACHED();
4138 return TransformStyle3D::Flat;
4139}
4140
4141template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TransformBox box)
4142 : CSSValue(PrimitiveClass)
4143{
4144 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
4145 switch (box) {
4146 case TransformBox::StrokeBox:
4147 m_value.valueID = CSSValueStrokeBox;
4148 break;
4149 case TransformBox::ContentBox:
4150 m_value.valueID = CSSValueContentBox;
4151 break;
4152 case TransformBox::BorderBox:
4153 m_value.valueID = CSSValueBorderBox;
4154 break;
4155 case TransformBox::FillBox:
4156 m_value.valueID = CSSValueFillBox;
4157 break;
4158 case TransformBox::ViewBox:
4159 m_value.valueID = CSSValueViewBox;
4160 break;
4161 }
4162}
4163
4164template<> inline CSSPrimitiveValue::operator TransformBox() const
4165{
4166 ASSERT(isValueID());
4167
4168 switch (m_value.valueID) {
4169 case CSSValueStrokeBox:
4170 return TransformBox::StrokeBox;
4171 case CSSValueContentBox:
4172 return TransformBox::ContentBox;
4173 case CSSValueBorderBox:
4174 return TransformBox::BorderBox;
4175 case CSSValueFillBox:
4176 return TransformBox::FillBox;
4177 case CSSValueViewBox:
4178 return TransformBox::ViewBox;
4179 default:
4180 break;
4181 }
4182
4183 ASSERT_NOT_REACHED();
4184 return TransformBox::BorderBox;
4185}
4186
4187template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ColumnAxis e)
4188 : CSSValue(PrimitiveClass)
4189{
4190 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
4191 switch (e) {
4192 case ColumnAxis::Horizontal:
4193 m_value.valueID = CSSValueHorizontal;
4194 break;
4195 case ColumnAxis::Vertical:
4196 m_value.valueID = CSSValueVertical;
4197 break;
4198 case ColumnAxis::Auto:
4199 m_value.valueID = CSSValueAuto;
4200 break;
4201 }
4202}
4203
4204template<> inline CSSPrimitiveValue::operator ColumnAxis() const
4205{
4206 ASSERT(isValueID());
4207
4208 switch (m_value.valueID) {
4209 case CSSValueHorizontal:
4210 return ColumnAxis::Horizontal;
4211 case CSSValueVertical:
4212 return ColumnAxis::Vertical;
4213 case CSSValueAuto:
4214 return ColumnAxis::Auto;
4215 default:
4216 break;
4217 }
4218
4219 ASSERT_NOT_REACHED();
4220 return ColumnAxis::Auto;
4221}
4222
4223template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ColumnProgression e)
4224 : CSSValue(PrimitiveClass)
4225{
4226 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
4227 switch (e) {
4228 case ColumnProgression::Normal:
4229 m_value.valueID = CSSValueNormal;
4230 break;
4231 case ColumnProgression::Reverse:
4232 m_value.valueID = CSSValueReverse;
4233 break;
4234 }
4235}
4236
4237template<> inline CSSPrimitiveValue::operator ColumnProgression() const
4238{
4239 ASSERT(isValueID());
4240
4241 switch (m_value.valueID) {
4242 case CSSValueNormal:
4243 return ColumnProgression::Normal;
4244 case CSSValueReverse:
4245 return ColumnProgression::Reverse;
4246 default:
4247 break;
4248 }
4249
4250 ASSERT_NOT_REACHED();
4251 return ColumnProgression::Normal;
4252}
4253
4254enum LengthConversion {
4255 AnyConversion = ~0,
4256 FixedIntegerConversion = 1 << 0,
4257 FixedFloatConversion = 1 << 1,
4258 AutoConversion = 1 << 2,
4259 PercentConversion = 1 << 3,
4260 CalculatedConversion = 1 << 4
4261};
4262
4263inline bool CSSPrimitiveValue::convertingToLengthRequiresNonNullStyle(int lengthConversion) const
4264{
4265 // This matches the implementation in CSSPrimitiveValue::computeLengthDouble().
4266 //
4267 // FIXME: We should probably make CSSPrimitiveValue::computeLengthDouble and
4268 // CSSPrimitiveValue::computeNonCalcLengthDouble (which has the style assertion)
4269 // return std::optional<double> instead of having this check here.
4270 switch (primitiveUnitType()) {
4271 case CSSUnitType::CSS_EMS:
4272 case CSSUnitType::CSS_EXS:
4273 case CSSUnitType::CSS_CHS:
4274 case CSSUnitType::CSS_IC:
4275 case CSSUnitType::CSS_LHS:
4276 return lengthConversion & (FixedIntegerConversion | FixedFloatConversion);
4277 case CSSUnitType::CSS_CALC:
4278 return m_value.calc->convertingToLengthRequiresNonNullStyle(lengthConversion);
4279 default:
4280 return false;
4281 }
4282}
4283
4284template<int supported> Length CSSPrimitiveValue::convertToLength(const CSSToLengthConversionData& conversionData) const
4285{
4286 if (convertingToLengthRequiresNonNullStyle(supported) && !conversionData.style())
4287 return Length(LengthType::Undefined);
4288 if ((supported & FixedIntegerConversion) && isLength())
4289 return computeLength<Length>(conversionData);
4290 if ((supported & FixedFloatConversion) && isLength())
4291 return Length(computeLength<double>(conversionData), LengthType::Fixed);
4292 if ((supported & PercentConversion) && isPercentage())
4293 return Length(doubleValue(), LengthType::Percent);
4294 if ((supported & AutoConversion) && valueID() == CSSValueAuto)
4295 return Length(LengthType::Auto);
4296 if ((supported & CalculatedConversion) && isCalculated())
4297 return Length(cssCalcValue()->createCalculationValue(conversionData));
4298 return Length(LengthType::Undefined);
4299}
4300
4301template<> inline CSSPrimitiveValue::CSSPrimitiveValue(BufferedRendering e)
4302 : CSSValue(PrimitiveClass)
4303{
4304 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
4305 switch (e) {
4306 case BufferedRendering::Auto:
4307 m_value.valueID = CSSValueAuto;
4308 break;
4309 case BufferedRendering::Dynamic:
4310 m_value.valueID = CSSValueDynamic;
4311 break;
4312 case BufferedRendering::Static:
4313 m_value.valueID = CSSValueStatic;
4314 break;
4315 }
4316}
4317
4318template<> inline CSSPrimitiveValue::operator BufferedRendering() const
4319{
4320 ASSERT(isValueID());
4321
4322 switch (m_value.valueID) {
4323 case CSSValueAuto:
4324 return BufferedRendering::Auto;
4325 case CSSValueDynamic:
4326 return BufferedRendering::Dynamic;
4327 case CSSValueStatic:
4328 return BufferedRendering::Static;
4329 default:
4330 break;
4331 }
4332
4333 ASSERT_NOT_REACHED();
4334 return BufferedRendering::Auto;
4335}
4336
4337template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ColorInterpolation e)
4338 : CSSValue(PrimitiveClass)
4339{
4340 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
4341 switch (e) {
4342 case ColorInterpolation::Auto:
4343 m_value.valueID = CSSValueAuto;
4344 break;
4345 case ColorInterpolation::SRGB:
4346 m_value.valueID = CSSValueSRGB;
4347 break;
4348 case ColorInterpolation::LinearRGB:
4349 m_value.valueID = CSSValueLinearRGB;
4350 break;
4351 }
4352}
4353
4354template<> inline CSSPrimitiveValue::operator ColorInterpolation() const
4355{
4356 ASSERT(isValueID());
4357
4358 switch (m_value.valueID) {
4359 case CSSValueSRGB:
4360 return ColorInterpolation::SRGB;
4361 case CSSValueLinearRGB:
4362 return ColorInterpolation::LinearRGB;
4363 case CSSValueAuto:
4364 return ColorInterpolation::Auto;
4365 default:
4366 break;
4367 }
4368
4369 ASSERT_NOT_REACHED();
4370 return ColorInterpolation::Auto;
4371}
4372
4373template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ColorRendering e)
4374 : CSSValue(PrimitiveClass)
4375{
4376 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
4377 switch (e) {
4378 case ColorRendering::Auto:
4379 m_value.valueID = CSSValueAuto;
4380 break;
4381 case ColorRendering::OptimizeSpeed:
4382 m_value.valueID = CSSValueOptimizeSpeed;
4383 break;
4384 case ColorRendering::OptimizeQuality:
4385 m_value.valueID = CSSValueOptimizeQuality;
4386 break;
4387 }
4388}
4389
4390template<> inline CSSPrimitiveValue::operator ColorRendering() const
4391{
4392 ASSERT(isValueID());
4393
4394 switch (m_value.valueID) {
4395 case CSSValueOptimizeSpeed:
4396 return ColorRendering::OptimizeSpeed;
4397 case CSSValueOptimizeQuality:
4398 return ColorRendering::OptimizeQuality;
4399 case CSSValueAuto:
4400 return ColorRendering::Auto;
4401 default:
4402 break;
4403 }
4404
4405 ASSERT_NOT_REACHED();
4406 return ColorRendering::Auto;
4407}
4408
4409template<> inline CSSPrimitiveValue::CSSPrimitiveValue(DominantBaseline e)
4410 : CSSValue(PrimitiveClass)
4411{
4412 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
4413 switch (e) {
4414 case DominantBaseline::Auto:
4415 m_value.valueID = CSSValueAuto;
4416 break;
4417 case DominantBaseline::UseScript:
4418 m_value.valueID = CSSValueUseScript;
4419 break;
4420 case DominantBaseline::NoChange:
4421 m_value.valueID = CSSValueNoChange;
4422 break;
4423 case DominantBaseline::ResetSize:
4424 m_value.valueID = CSSValueResetSize;
4425 break;
4426 case DominantBaseline::Central:
4427 m_value.valueID = CSSValueCentral;
4428 break;
4429 case DominantBaseline::Middle:
4430 m_value.valueID = CSSValueMiddle;
4431 break;
4432 case DominantBaseline::TextBeforeEdge:
4433 m_value.valueID = CSSValueTextBeforeEdge;
4434 break;
4435 case DominantBaseline::TextAfterEdge:
4436 m_value.valueID = CSSValueTextAfterEdge;
4437 break;
4438 case DominantBaseline::Ideographic:
4439 m_value.valueID = CSSValueIdeographic;
4440 break;
4441 case DominantBaseline::Alphabetic:
4442 m_value.valueID = CSSValueAlphabetic;
4443 break;
4444 case DominantBaseline::Hanging:
4445 m_value.valueID = CSSValueHanging;
4446 break;
4447 case DominantBaseline::Mathematical:
4448 m_value.valueID = CSSValueMathematical;
4449 break;
4450 }
4451}
4452
4453template<> inline CSSPrimitiveValue::operator DominantBaseline() const
4454{
4455 ASSERT(isValueID());
4456
4457 switch (m_value.valueID) {
4458 case CSSValueAuto:
4459 return DominantBaseline::Auto;
4460 case CSSValueUseScript:
4461 return DominantBaseline::UseScript;
4462 case CSSValueNoChange:
4463 return DominantBaseline::NoChange;
4464 case CSSValueResetSize:
4465 return DominantBaseline::ResetSize;
4466 case CSSValueIdeographic:
4467 return DominantBaseline::Ideographic;
4468 case CSSValueAlphabetic:
4469 return DominantBaseline::Alphabetic;
4470 case CSSValueHanging:
4471 return DominantBaseline::Hanging;
4472 case CSSValueMathematical:
4473 return DominantBaseline::Mathematical;
4474 case CSSValueCentral:
4475 return DominantBaseline::Central;
4476 case CSSValueMiddle:
4477 return DominantBaseline::Middle;
4478 case CSSValueTextAfterEdge:
4479 return DominantBaseline::TextAfterEdge;
4480 case CSSValueTextBeforeEdge:
4481 return DominantBaseline::TextBeforeEdge;
4482 default:
4483 break;
4484 }
4485
4486 ASSERT_NOT_REACHED();
4487 return DominantBaseline::Auto;
4488}
4489
4490template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ShapeRendering e)
4491 : CSSValue(PrimitiveClass)
4492{
4493 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
4494 switch (e) {
4495 case ShapeRendering::Auto:
4496 m_value.valueID = CSSValueAuto;
4497 break;
4498 case ShapeRendering::OptimizeSpeed:
4499 m_value.valueID = CSSValueOptimizeSpeed;
4500 break;
4501 case ShapeRendering::CrispEdges:
4502 m_value.valueID = CSSValueCrispedges;
4503 break;
4504 case ShapeRendering::GeometricPrecision:
4505 m_value.valueID = CSSValueGeometricPrecision;
4506 break;
4507 }
4508}
4509
4510template<> inline CSSPrimitiveValue::operator ShapeRendering() const
4511{
4512 ASSERT(isValueID());
4513
4514 switch (m_value.valueID) {
4515 case CSSValueAuto:
4516 return ShapeRendering::Auto;
4517 case CSSValueOptimizeSpeed:
4518 return ShapeRendering::OptimizeSpeed;
4519 case CSSValueCrispedges:
4520 return ShapeRendering::CrispEdges;
4521 case CSSValueGeometricPrecision:
4522 return ShapeRendering::GeometricPrecision;
4523 default:
4524 break;
4525 }
4526
4527 ASSERT_NOT_REACHED();
4528 return ShapeRendering::Auto;
4529}
4530
4531template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextAnchor e)
4532 : CSSValue(PrimitiveClass)
4533{
4534 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
4535 switch (e) {
4536 case TextAnchor::Start:
4537 m_value.valueID = CSSValueStart;
4538 break;
4539 case TextAnchor::Middle:
4540 m_value.valueID = CSSValueMiddle;
4541 break;
4542 case TextAnchor::End:
4543 m_value.valueID = CSSValueEnd;
4544 break;
4545 }
4546}
4547
4548template<> inline CSSPrimitiveValue::operator TextAnchor() const
4549{
4550 ASSERT(isValueID());
4551
4552 switch (m_value.valueID) {
4553 case CSSValueStart:
4554 return TextAnchor::Start;
4555 case CSSValueMiddle:
4556 return TextAnchor::Middle;
4557 case CSSValueEnd:
4558 return TextAnchor::End;
4559 default:
4560 break;
4561 }
4562
4563 ASSERT_NOT_REACHED();
4564 return TextAnchor::Start;
4565}
4566
4567template<> inline CSSPrimitiveValue::CSSPrimitiveValue(const Color& color)
4568 : CSSValue(PrimitiveClass)
4569{
4570 setPrimitiveUnitType(CSSUnitType::CSS_RGBCOLOR);
4571 m_value.color = new Color(color);
4572}
4573
4574template<> inline CSSPrimitiveValue::CSSPrimitiveValue(CSSFontFamily fontFamily)
4575 : CSSValue(PrimitiveClass)
4576{
4577 setPrimitiveUnitType(CSSUnitType::CSS_FONT_FAMILY);
4578 m_value.fontFamily = new CSSFontFamily(WTFMove(fontFamily));
4579}
4580
4581template<> inline CSSPrimitiveValue::CSSPrimitiveValue(VectorEffect e)
4582 : CSSValue(PrimitiveClass)
4583{
4584 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
4585 switch (e) {
4586 case VectorEffect::None:
4587 m_value.valueID = CSSValueNone;
4588 break;
4589 case VectorEffect::NonScalingStroke:
4590 m_value.valueID = CSSValueNonScalingStroke;
4591 break;
4592 }
4593}
4594
4595template<> inline CSSPrimitiveValue::operator VectorEffect() const
4596{
4597 ASSERT(isValueID());
4598
4599 switch (m_value.valueID) {
4600 case CSSValueNone:
4601 return VectorEffect::None;
4602 case CSSValueNonScalingStroke:
4603 return VectorEffect::NonScalingStroke;
4604 default:
4605 break;
4606 }
4607
4608 ASSERT_NOT_REACHED();
4609 return VectorEffect::None;
4610}
4611
4612template<> inline CSSPrimitiveValue::CSSPrimitiveValue(MaskType e)
4613 : CSSValue(PrimitiveClass)
4614{
4615 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
4616 switch (e) {
4617 case MaskType::Luminance:
4618 m_value.valueID = CSSValueLuminance;
4619 break;
4620 case MaskType::Alpha:
4621 m_value.valueID = CSSValueAlpha;
4622 break;
4623 }
4624}
4625
4626template<> inline CSSPrimitiveValue::operator MaskType() const
4627{
4628 ASSERT(isValueID());
4629
4630 switch (m_value.valueID) {
4631 case CSSValueLuminance:
4632 return MaskType::Luminance;
4633 case CSSValueAlpha:
4634 return MaskType::Alpha;
4635 default:
4636 break;
4637 }
4638
4639 ASSERT_NOT_REACHED();
4640 return MaskType::Luminance;
4641}
4642
4643template<> inline CSSPrimitiveValue::CSSPrimitiveValue(CSSBoxType cssBox)
4644 : CSSValue(PrimitiveClass)
4645{
4646 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
4647 switch (cssBox) {
4648 case CSSBoxType::MarginBox:
4649 m_value.valueID = CSSValueMarginBox;
4650 break;
4651 case CSSBoxType::BorderBox:
4652 m_value.valueID = CSSValueBorderBox;
4653 break;
4654 case CSSBoxType::PaddingBox:
4655 m_value.valueID = CSSValuePaddingBox;
4656 break;
4657 case CSSBoxType::ContentBox:
4658 m_value.valueID = CSSValueContentBox;
4659 break;
4660 case CSSBoxType::FillBox:
4661 m_value.valueID = CSSValueFillBox;
4662 break;
4663 case CSSBoxType::StrokeBox:
4664 m_value.valueID = CSSValueStrokeBox;
4665 break;
4666 case CSSBoxType::ViewBox:
4667 m_value.valueID = CSSValueViewBox;
4668 break;
4669 case CSSBoxType::BoxMissing:
4670 ASSERT_NOT_REACHED();
4671 m_value.valueID = CSSValueNone;
4672 break;
4673 }
4674}
4675
4676template<> inline CSSPrimitiveValue::operator CSSBoxType() const
4677{
4678 switch (valueID()) {
4679 case CSSValueMarginBox:
4680 return CSSBoxType::MarginBox;
4681 case CSSValueBorderBox:
4682 return CSSBoxType::BorderBox;
4683 case CSSValuePaddingBox:
4684 return CSSBoxType::PaddingBox;
4685 case CSSValueContentBox:
4686 return CSSBoxType::ContentBox;
4687 // The following are used in an SVG context.
4688 case CSSValueFillBox:
4689 return CSSBoxType::FillBox;
4690 case CSSValueStrokeBox:
4691 return CSSBoxType::StrokeBox;
4692 case CSSValueViewBox:
4693 return CSSBoxType::ViewBox;
4694 default:
4695 break;
4696 }
4697 ASSERT_NOT_REACHED();
4698 return CSSBoxType::BoxMissing;
4699}
4700
4701template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ItemPosition itemPosition)
4702 : CSSValue(PrimitiveClass)
4703{
4704 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
4705 switch (itemPosition) {
4706 case ItemPosition::Legacy:
4707 m_value.valueID = CSSValueLegacy;
4708 break;
4709 case ItemPosition::Auto:
4710 m_value.valueID = CSSValueAuto;
4711 break;
4712 case ItemPosition::Normal:
4713 m_value.valueID = CSSValueNormal;
4714 break;
4715 case ItemPosition::Stretch:
4716 m_value.valueID = CSSValueStretch;
4717 break;
4718 case ItemPosition::Baseline:
4719 m_value.valueID = CSSValueBaseline;
4720 break;
4721 case ItemPosition::LastBaseline:
4722 m_value.valueID = CSSValueLastBaseline;
4723 break;
4724 case ItemPosition::Center:
4725 m_value.valueID = CSSValueCenter;
4726 break;
4727 case ItemPosition::Start:
4728 m_value.valueID = CSSValueStart;
4729 break;
4730 case ItemPosition::End:
4731 m_value.valueID = CSSValueEnd;
4732 break;
4733 case ItemPosition::SelfStart:
4734 m_value.valueID = CSSValueSelfStart;
4735 break;
4736 case ItemPosition::SelfEnd:
4737 m_value.valueID = CSSValueSelfEnd;
4738 break;
4739 case ItemPosition::FlexStart:
4740 m_value.valueID = CSSValueFlexStart;
4741 break;
4742 case ItemPosition::FlexEnd:
4743 m_value.valueID = CSSValueFlexEnd;
4744 break;
4745 case ItemPosition::Left:
4746 m_value.valueID = CSSValueLeft;
4747 break;
4748 case ItemPosition::Right:
4749 m_value.valueID = CSSValueRight;
4750 break;
4751 }
4752}
4753
4754template<> inline CSSPrimitiveValue::operator ItemPosition() const
4755{
4756 switch (m_value.valueID) {
4757 case CSSValueLegacy:
4758 return ItemPosition::Legacy;
4759 case CSSValueAuto:
4760 return ItemPosition::Auto;
4761 case CSSValueNormal:
4762 return ItemPosition::Normal;
4763 case CSSValueStretch:
4764 return ItemPosition::Stretch;
4765 case CSSValueBaseline:
4766 return ItemPosition::Baseline;
4767 case CSSValueFirstBaseline:
4768 return ItemPosition::Baseline;
4769 case CSSValueLastBaseline:
4770 return ItemPosition::LastBaseline;
4771 case CSSValueCenter:
4772 return ItemPosition::Center;
4773 case CSSValueStart:
4774 return ItemPosition::Start;
4775 case CSSValueEnd:
4776 return ItemPosition::End;
4777 case CSSValueSelfStart:
4778 return ItemPosition::SelfStart;
4779 case CSSValueSelfEnd:
4780 return ItemPosition::SelfEnd;
4781 case CSSValueFlexStart:
4782 return ItemPosition::FlexStart;
4783 case CSSValueFlexEnd:
4784 return ItemPosition::FlexEnd;
4785 case CSSValueLeft:
4786 return ItemPosition::Left;
4787 case CSSValueRight:
4788 return ItemPosition::Right;
4789 default:
4790 break;
4791 }
4792 ASSERT_NOT_REACHED();
4793 return ItemPosition::Auto;
4794}
4795
4796template<> inline CSSPrimitiveValue::CSSPrimitiveValue(OverflowAlignment overflowAlignment)
4797 : CSSValue(PrimitiveClass)
4798{
4799 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
4800 switch (overflowAlignment) {
4801 case OverflowAlignment::Default:
4802 m_value.valueID = CSSValueDefault;
4803 break;
4804 case OverflowAlignment::Unsafe:
4805 m_value.valueID = CSSValueUnsafe;
4806 break;
4807 case OverflowAlignment::Safe:
4808 m_value.valueID = CSSValueSafe;
4809 break;
4810 }
4811}
4812
4813template<> inline CSSPrimitiveValue::operator OverflowAlignment() const
4814{
4815 switch (m_value.valueID) {
4816 case CSSValueUnsafe:
4817 return OverflowAlignment::Unsafe;
4818 case CSSValueSafe:
4819 return OverflowAlignment::Safe;
4820 default:
4821 break;
4822 }
4823 ASSERT_NOT_REACHED();
4824 return OverflowAlignment::Unsafe;
4825}
4826
4827template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ContentPosition contentPosition)
4828 : CSSValue(PrimitiveClass)
4829{
4830 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
4831 switch (contentPosition) {
4832 case ContentPosition::Normal:
4833 m_value.valueID = CSSValueNormal;
4834 break;
4835 case ContentPosition::Baseline:
4836 m_value.valueID = CSSValueBaseline;
4837 break;
4838 case ContentPosition::LastBaseline:
4839 m_value.valueID = CSSValueLastBaseline;
4840 break;
4841 case ContentPosition::Center:
4842 m_value.valueID = CSSValueCenter;
4843 break;
4844 case ContentPosition::Start:
4845 m_value.valueID = CSSValueStart;
4846 break;
4847 case ContentPosition::End:
4848 m_value.valueID = CSSValueEnd;
4849 break;
4850 case ContentPosition::FlexStart:
4851 m_value.valueID = CSSValueFlexStart;
4852 break;
4853 case ContentPosition::FlexEnd:
4854 m_value.valueID = CSSValueFlexEnd;
4855 break;
4856 case ContentPosition::Left:
4857 m_value.valueID = CSSValueLeft;
4858 break;
4859 case ContentPosition::Right:
4860 m_value.valueID = CSSValueRight;
4861 break;
4862 }
4863}
4864
4865template<> inline CSSPrimitiveValue::operator ContentPosition() const
4866{
4867 switch (m_value.valueID) {
4868 case CSSValueNormal:
4869 return ContentPosition::Normal;
4870 case CSSValueBaseline:
4871 return ContentPosition::Baseline;
4872 case CSSValueFirstBaseline:
4873 return ContentPosition::Baseline;
4874 case CSSValueLastBaseline:
4875 return ContentPosition::LastBaseline;
4876 case CSSValueCenter:
4877 return ContentPosition::Center;
4878 case CSSValueStart:
4879 return ContentPosition::Start;
4880 case CSSValueEnd:
4881 return ContentPosition::End;
4882 case CSSValueFlexStart:
4883 return ContentPosition::FlexStart;
4884 case CSSValueFlexEnd:
4885 return ContentPosition::FlexEnd;
4886 case CSSValueLeft:
4887 return ContentPosition::Left;
4888 case CSSValueRight:
4889 return ContentPosition::Right;
4890 default:
4891 break;
4892 }
4893 ASSERT_NOT_REACHED();
4894 return ContentPosition::Normal;
4895}
4896
4897template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ContentDistribution contentDistribution)
4898 : CSSValue(PrimitiveClass)
4899{
4900 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
4901 switch (contentDistribution) {
4902 case ContentDistribution::Default:
4903 m_value.valueID = CSSValueDefault;
4904 break;
4905 case ContentDistribution::SpaceBetween:
4906 m_value.valueID = CSSValueSpaceBetween;
4907 break;
4908 case ContentDistribution::SpaceAround:
4909 m_value.valueID = CSSValueSpaceAround;
4910 break;
4911 case ContentDistribution::SpaceEvenly:
4912 m_value.valueID = CSSValueSpaceEvenly;
4913 break;
4914 case ContentDistribution::Stretch:
4915 m_value.valueID = CSSValueStretch;
4916 break;
4917 }
4918}
4919
4920template<> inline CSSPrimitiveValue::operator ContentDistribution() const
4921{
4922 switch (m_value.valueID) {
4923 case CSSValueSpaceBetween:
4924 return ContentDistribution::SpaceBetween;
4925 case CSSValueSpaceAround:
4926 return ContentDistribution::SpaceAround;
4927 case CSSValueSpaceEvenly:
4928 return ContentDistribution::SpaceEvenly;
4929 case CSSValueStretch:
4930 return ContentDistribution::Stretch;
4931 default:
4932 break;
4933 }
4934 ASSERT_NOT_REACHED();
4935 return ContentDistribution::Stretch;
4936}
4937
4938template<> inline CSSPrimitiveValue::operator TextZoom() const
4939{
4940 ASSERT(isValueID());
4941
4942 switch (m_value.valueID) {
4943 case CSSValueNormal:
4944 return TextZoom::Normal;
4945 case CSSValueReset:
4946 return TextZoom::Reset;
4947 default:
4948 break;
4949 }
4950
4951 ASSERT_NOT_REACHED();
4952 return TextZoom::Normal;
4953}
4954
4955template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextZoom textZoom)
4956 : CSSValue(PrimitiveClass)
4957{
4958 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
4959 switch (textZoom) {
4960 case TextZoom::Normal:
4961 m_value.valueID = CSSValueNormal;
4962 return;
4963 case TextZoom::Reset:
4964 m_value.valueID = CSSValueReset;
4965 return;
4966 }
4967
4968 ASSERT_NOT_REACHED();
4969 m_value.valueID = CSSValueNormal;
4970}
4971
4972template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TouchAction touchAction)
4973 : CSSValue(PrimitiveClass)
4974{
4975 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
4976 switch (touchAction) {
4977 case TouchAction::Auto:
4978 m_value.valueID = CSSValueAuto;
4979 break;
4980 case TouchAction::Manipulation:
4981 m_value.valueID = CSSValueManipulation;
4982 break;
4983 case TouchAction::None:
4984 m_value.valueID = CSSValueNone;
4985 break;
4986 case TouchAction::PanX:
4987 m_value.valueID = CSSValuePanX;
4988 break;
4989 case TouchAction::PanY:
4990 m_value.valueID = CSSValuePanY;
4991 break;
4992 case TouchAction::PinchZoom:
4993 m_value.valueID = CSSValuePinchZoom;
4994 break;
4995 }
4996}
4997
4998template<> inline CSSPrimitiveValue::operator OptionSet<TouchAction>() const
4999{
5000 ASSERT(isValueID());
5001 switch (m_value.valueID) {
5002 case CSSValueAuto:
5003 return TouchAction::Auto;
5004 case CSSValueManipulation:
5005 return TouchAction::Manipulation;
5006 case CSSValueNone:
5007 return TouchAction::None;
5008 case CSSValuePanX:
5009 return TouchAction::PanX;
5010 case CSSValuePanY:
5011 return TouchAction::PanY;
5012 case CSSValuePinchZoom:
5013 return TouchAction::PinchZoom;
5014 default:
5015 break;
5016 }
5017 ASSERT_NOT_REACHED();
5018 return TouchAction::Auto;
5019}
5020
5021template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ScrollSnapStrictness strictness)
5022 : CSSValue(PrimitiveClass)
5023{
5024 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
5025 switch (strictness) {
5026 case ScrollSnapStrictness::None:
5027 m_value.valueID = CSSValueNone;
5028 break;
5029 case ScrollSnapStrictness::Proximity:
5030 m_value.valueID = CSSValueProximity;
5031 break;
5032 case ScrollSnapStrictness::Mandatory:
5033 m_value.valueID = CSSValueMandatory;
5034 break;
5035 }
5036}
5037
5038template<> inline CSSPrimitiveValue::operator ScrollSnapStrictness() const
5039{
5040 ASSERT(isValueID());
5041 switch (m_value.valueID) {
5042 case CSSValueNone:
5043 return ScrollSnapStrictness::None;
5044 case CSSValueProximity:
5045 return ScrollSnapStrictness::Proximity;
5046 case CSSValueMandatory:
5047 return ScrollSnapStrictness::Mandatory;
5048 default:
5049 ASSERT_NOT_REACHED();
5050 return ScrollSnapStrictness::None;
5051 }
5052}
5053
5054template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ScrollSnapAxis axis)
5055 : CSSValue(PrimitiveClass)
5056{
5057 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
5058 switch (axis) {
5059 case ScrollSnapAxis::XAxis:
5060 m_value.valueID = CSSValueX;
5061 break;
5062 case ScrollSnapAxis::YAxis:
5063 m_value.valueID = CSSValueY;
5064 break;
5065 case ScrollSnapAxis::Block:
5066 m_value.valueID = CSSValueBlock;
5067 break;
5068 case ScrollSnapAxis::Inline:
5069 m_value.valueID = CSSValueInline;
5070 break;
5071 case ScrollSnapAxis::Both:
5072 m_value.valueID = CSSValueBoth;
5073 break;
5074 }
5075}
5076
5077template<> inline CSSPrimitiveValue::operator ScrollSnapAxis() const
5078{
5079 ASSERT(isValueID());
5080 switch (m_value.valueID) {
5081 case CSSValueX:
5082 return ScrollSnapAxis::XAxis;
5083 case CSSValueY:
5084 return ScrollSnapAxis::YAxis;
5085 case CSSValueBlock:
5086 return ScrollSnapAxis::Block;
5087 case CSSValueInline:
5088 return ScrollSnapAxis::Inline;
5089 case CSSValueBoth:
5090 return ScrollSnapAxis::Both;
5091 default:
5092 ASSERT_NOT_REACHED();
5093 return ScrollSnapAxis::Both;
5094 }
5095}
5096
5097template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ScrollSnapAxisAlignType type)
5098 : CSSValue(PrimitiveClass)
5099{
5100 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
5101 switch (type) {
5102 case ScrollSnapAxisAlignType::None:
5103 m_value.valueID = CSSValueNone;
5104 break;
5105 case ScrollSnapAxisAlignType::Start:
5106 m_value.valueID = CSSValueStart;
5107 break;
5108 case ScrollSnapAxisAlignType::Center:
5109 m_value.valueID = CSSValueCenter;
5110 break;
5111 case ScrollSnapAxisAlignType::End:
5112 m_value.valueID = CSSValueEnd;
5113 break;
5114 }
5115}
5116
5117template<> inline CSSPrimitiveValue::operator ScrollSnapAxisAlignType() const
5118{
5119 ASSERT(isValueID());
5120 switch (m_value.valueID) {
5121 case CSSValueNone:
5122 return ScrollSnapAxisAlignType::None;
5123 case CSSValueStart:
5124 return ScrollSnapAxisAlignType::Start;
5125 case CSSValueCenter:
5126 return ScrollSnapAxisAlignType::Center;
5127 case CSSValueEnd:
5128 return ScrollSnapAxisAlignType::End;
5129 default:
5130 ASSERT_NOT_REACHED();
5131 return ScrollSnapAxisAlignType::None;
5132 }
5133}
5134
5135template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ScrollSnapStop snapStop)
5136 : CSSValue(PrimitiveClass)
5137{
5138 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
5139 switch (snapStop) {
5140 case ScrollSnapStop::Normal:
5141 m_value.valueID = CSSValueNormal;
5142 break;
5143 case ScrollSnapStop::Always:
5144 m_value.valueID = CSSValueAlways;
5145 break;
5146 }
5147}
5148
5149template<> inline CSSPrimitiveValue::operator ScrollSnapStop() const
5150{
5151 ASSERT(isValueID());
5152 switch (m_value.valueID) {
5153 case CSSValueNormal:
5154 return ScrollSnapStop::Normal;
5155 case CSSValueAlways:
5156 return ScrollSnapStop::Always;
5157 default:
5158 ASSERT_NOT_REACHED();
5159 return ScrollSnapStop::Normal;
5160 }
5161}
5162
5163#if ENABLE(CSS_TRAILING_WORD)
5164template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TrailingWord e)
5165 : CSSValue(PrimitiveClass)
5166{
5167 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
5168 switch (e) {
5169 case TrailingWord::Auto:
5170 m_value.valueID = CSSValueAuto;
5171 break;
5172 case TrailingWord::PartiallyBalanced:
5173 m_value.valueID = CSSValueWebkitPartiallyBalanced;
5174 break;
5175 default:
5176 ASSERT_NOT_REACHED();
5177 break;
5178 }
5179}
5180
5181template<> inline CSSPrimitiveValue::operator TrailingWord() const
5182{
5183 ASSERT(isValueID());
5184 switch (m_value.valueID) {
5185 case CSSValueAuto:
5186 return TrailingWord::Auto;
5187 case CSSValueWebkitPartiallyBalanced:
5188 return TrailingWord::PartiallyBalanced;
5189 default:
5190 break;
5191 }
5192 ASSERT_NOT_REACHED();
5193 return TrailingWord::Auto;
5194}
5195#endif
5196
5197#if ENABLE(APPLE_PAY)
5198template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ApplePayButtonStyle e)
5199 : CSSValue(PrimitiveClass)
5200{
5201 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
5202 switch (e) {
5203 case ApplePayButtonStyle::White:
5204 m_value.valueID = CSSValueWhite;
5205 break;
5206 case ApplePayButtonStyle::WhiteOutline:
5207 m_value.valueID = CSSValueWhiteOutline;
5208 break;
5209 case ApplePayButtonStyle::Black:
5210 m_value.valueID = CSSValueBlack;
5211 break;
5212 default:
5213 ASSERT_NOT_REACHED();
5214 break;
5215 }
5216}
5217
5218template<> inline CSSPrimitiveValue::operator ApplePayButtonStyle() const
5219{
5220 ASSERT(isValueID());
5221 switch (m_value.valueID) {
5222 case CSSValueWhite:
5223 return ApplePayButtonStyle::White;
5224 case CSSValueWhiteOutline:
5225 return ApplePayButtonStyle::WhiteOutline;
5226 case CSSValueBlack:
5227 return ApplePayButtonStyle::Black;
5228 default:
5229 break;
5230 }
5231 ASSERT_NOT_REACHED();
5232 return ApplePayButtonStyle::Black;
5233}
5234
5235template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ApplePayButtonType e)
5236 : CSSValue(PrimitiveClass)
5237{
5238 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
5239 switch (e) {
5240 case ApplePayButtonType::Plain:
5241 m_value.valueID = CSSValuePlain;
5242 break;
5243 case ApplePayButtonType::Buy:
5244 m_value.valueID = CSSValueBuy;
5245 break;
5246 case ApplePayButtonType::SetUp:
5247 m_value.valueID = CSSValueSetUp;
5248 break;
5249 case ApplePayButtonType::Donate:
5250 m_value.valueID = CSSValueDonate;
5251 break;
5252 case ApplePayButtonType::CheckOut:
5253 m_value.valueID = CSSValueCheckOut;
5254 break;
5255 case ApplePayButtonType::Book:
5256 m_value.valueID = CSSValueBook;
5257 break;
5258 case ApplePayButtonType::Subscribe:
5259 m_value.valueID = CSSValueSubscribe;
5260 break;
5261#if ENABLE(APPLE_PAY_NEW_BUTTON_TYPES)
5262 case ApplePayButtonType::Reload:
5263 m_value.valueID = CSSValueReload;
5264 break;
5265 case ApplePayButtonType::AddMoney:
5266 m_value.valueID = CSSValueAddMoney;
5267 break;
5268 case ApplePayButtonType::TopUp:
5269 m_value.valueID = CSSValueTopUp;
5270 break;
5271 case ApplePayButtonType::Order:
5272 m_value.valueID = CSSValueOrder;
5273 break;
5274 case ApplePayButtonType::Rent:
5275 m_value.valueID = CSSValueRent;
5276 break;
5277 case ApplePayButtonType::Support:
5278 m_value.valueID = CSSValueSupport;
5279 break;
5280 case ApplePayButtonType::Contribute:
5281 m_value.valueID = CSSValueContribute;
5282 break;
5283 case ApplePayButtonType::Tip:
5284 m_value.valueID = CSSValueTip;
5285 break;
5286#endif
5287 default:
5288 ASSERT_NOT_REACHED();
5289 break;
5290 }
5291}
5292
5293template<> inline CSSPrimitiveValue::operator ApplePayButtonType() const
5294{
5295 ASSERT(isValueID());
5296 switch (m_value.valueID) {
5297 case CSSValuePlain:
5298 return ApplePayButtonType::Plain;
5299 case CSSValueBuy:
5300 return ApplePayButtonType::Buy;
5301 case CSSValueSetUp:
5302 return ApplePayButtonType::SetUp;
5303 case CSSValueDonate:
5304 return ApplePayButtonType::Donate;
5305 case CSSValueCheckOut:
5306 return ApplePayButtonType::CheckOut;
5307 case CSSValueBook:
5308 return ApplePayButtonType::Book;
5309 case CSSValueSubscribe:
5310 return ApplePayButtonType::Subscribe;
5311#if ENABLE(APPLE_PAY_NEW_BUTTON_TYPES)
5312 case CSSValueReload:
5313 return ApplePayButtonType::Reload;
5314 case CSSValueAddMoney:
5315 return ApplePayButtonType::AddMoney;
5316 case CSSValueTopUp:
5317 return ApplePayButtonType::TopUp;
5318 case CSSValueOrder:
5319 return ApplePayButtonType::Order;
5320 case CSSValueRent:
5321 return ApplePayButtonType::Rent;
5322 case CSSValueSupport:
5323 return ApplePayButtonType::Support;
5324 case CSSValueContribute:
5325 return ApplePayButtonType::Contribute;
5326 case CSSValueTip:
5327 return ApplePayButtonType::Tip;
5328#endif
5329 default:
5330 break;
5331 }
5332 ASSERT_NOT_REACHED();
5333 return ApplePayButtonType::Plain;
5334}
5335#endif
5336
5337template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontVariantPosition position)
5338 : CSSValue(PrimitiveClass)
5339{
5340 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
5341 switch (position) {
5342 case FontVariantPosition::Normal:
5343 m_value.valueID = CSSValueNormal;
5344 break;
5345 case FontVariantPosition::Subscript:
5346 m_value.valueID = CSSValueSub;
5347 break;
5348 case FontVariantPosition::Superscript:
5349 m_value.valueID = CSSValueSuper;
5350 break;
5351 default:
5352 ASSERT_NOT_REACHED();
5353 break;
5354 }
5355}
5356
5357template<> inline CSSPrimitiveValue::operator FontVariantPosition() const
5358{
5359 ASSERT(isValueID());
5360 switch (m_value.valueID) {
5361 case CSSValueNormal:
5362 return FontVariantPosition::Normal;
5363 case CSSValueSub:
5364 return FontVariantPosition::Subscript;
5365 case CSSValueSuper:
5366 return FontVariantPosition::Superscript;
5367 default:
5368 break;
5369 }
5370 ASSERT_NOT_REACHED();
5371 return FontVariantPosition::Normal;
5372}
5373
5374template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontVariantCaps caps)
5375 : CSSValue(PrimitiveClass)
5376{
5377 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
5378 switch (caps) {
5379 case FontVariantCaps::Normal:
5380 m_value.valueID = CSSValueNormal;
5381 break;
5382 case FontVariantCaps::Small:
5383 m_value.valueID = CSSValueSmallCaps;
5384 break;
5385 case FontVariantCaps::AllSmall:
5386 m_value.valueID = CSSValueAllSmallCaps;
5387 break;
5388 case FontVariantCaps::Petite:
5389 m_value.valueID = CSSValuePetiteCaps;
5390 break;
5391 case FontVariantCaps::AllPetite:
5392 m_value.valueID = CSSValueAllPetiteCaps;
5393 break;
5394 case FontVariantCaps::Unicase:
5395 m_value.valueID = CSSValueUnicase;
5396 break;
5397 case FontVariantCaps::Titling:
5398 m_value.valueID = CSSValueTitlingCaps;
5399 break;
5400 default:
5401 ASSERT_NOT_REACHED();
5402 break;
5403 }
5404}
5405
5406template<> inline CSSPrimitiveValue::operator FontVariantCaps() const
5407{
5408 ASSERT(isValueID());
5409 switch (m_value.valueID) {
5410 case CSSValueNormal:
5411 return FontVariantCaps::Normal;
5412 case CSSValueSmallCaps:
5413 return FontVariantCaps::Small;
5414 case CSSValueAllSmallCaps:
5415 return FontVariantCaps::AllSmall;
5416 case CSSValuePetiteCaps:
5417 return FontVariantCaps::Petite;
5418 case CSSValueAllPetiteCaps:
5419 return FontVariantCaps::AllPetite;
5420 case CSSValueUnicase:
5421 return FontVariantCaps::Unicase;
5422 case CSSValueTitlingCaps:
5423 return FontVariantCaps::Titling;
5424 default:
5425 break;
5426 }
5427 ASSERT_NOT_REACHED();
5428 return FontVariantCaps::Normal;
5429}
5430
5431template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontVariantAlternates alternates)
5432 : CSSValue(PrimitiveClass)
5433{
5434 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
5435 switch (alternates) {
5436 case FontVariantAlternates::Normal:
5437 m_value.valueID = CSSValueNormal;
5438 break;
5439 case FontVariantAlternates::HistoricalForms:
5440 m_value.valueID = CSSValueHistoricalForms;
5441 break;
5442 default:
5443 ASSERT_NOT_REACHED();
5444 break;
5445 }
5446}
5447
5448template<> inline CSSPrimitiveValue::operator FontVariantAlternates() const
5449{
5450 ASSERT(isValueID());
5451 switch (m_value.valueID) {
5452 case CSSValueNormal:
5453 return FontVariantAlternates::Normal;
5454 case CSSValueHistoricalForms:
5455 return FontVariantAlternates::HistoricalForms;
5456 default:
5457 break;
5458 }
5459 ASSERT_NOT_REACHED();
5460 return FontVariantAlternates::Normal;
5461}
5462
5463template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontOpticalSizing sizing)
5464 : CSSValue(PrimitiveClass)
5465{
5466 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
5467 switch (sizing) {
5468 case FontOpticalSizing::Enabled:
5469 m_value.valueID = CSSValueAuto;
5470 break;
5471 case FontOpticalSizing::Disabled:
5472 m_value.valueID = CSSValueNone;
5473 break;
5474 default:
5475 ASSERT_NOT_REACHED();
5476 break;
5477 }
5478}
5479
5480template<> inline CSSPrimitiveValue::operator FontOpticalSizing() const
5481{
5482 ASSERT(isValueID());
5483 switch (m_value.valueID) {
5484 case CSSValueAuto:
5485 return FontOpticalSizing::Enabled;
5486 case CSSValueNone:
5487 return FontOpticalSizing::Disabled;
5488 default:
5489 break;
5490 }
5491 ASSERT_NOT_REACHED();
5492 return FontOpticalSizing::Enabled;
5493}
5494
5495template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontLoadingBehavior behavior)
5496 : CSSValue(PrimitiveClass)
5497{
5498 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
5499 switch (behavior) {
5500 case FontLoadingBehavior::Auto:
5501 m_value.valueID = CSSValueAuto;
5502 break;
5503 case FontLoadingBehavior::Block:
5504 m_value.valueID = CSSValueBlock;
5505 break;
5506 case FontLoadingBehavior::Swap:
5507 m_value.valueID = CSSValueSwap;
5508 break;
5509 case FontLoadingBehavior::Fallback:
5510 m_value.valueID = CSSValueFallback;
5511 break;
5512 case FontLoadingBehavior::Optional:
5513 m_value.valueID = CSSValueOptional;
5514 break;
5515 default:
5516 ASSERT_NOT_REACHED();
5517 break;
5518 }
5519}
5520
5521template<> inline CSSPrimitiveValue::operator FontLoadingBehavior() const
5522{
5523 ASSERT(isValueID());
5524 switch (m_value.valueID) {
5525 case CSSValueAuto:
5526 return FontLoadingBehavior::Auto;
5527 case CSSValueBlock:
5528 return FontLoadingBehavior::Block;
5529 case CSSValueSwap:
5530 return FontLoadingBehavior::Swap;
5531 case CSSValueFallback:
5532 return FontLoadingBehavior::Fallback;
5533 case CSSValueOptional:
5534 return FontLoadingBehavior::Optional;
5535 default:
5536 break;
5537 }
5538 ASSERT_NOT_REACHED();
5539 return FontLoadingBehavior::Auto;
5540}
5541
5542template<> inline CSSPrimitiveValue::CSSPrimitiveValue(MathStyle mathStyle)
5543 : CSSValue(PrimitiveClass)
5544{
5545 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
5546 switch (mathStyle) {
5547 case MathStyle::Normal:
5548 m_value.valueID = CSSValueNormal;
5549 break;
5550 case MathStyle::Compact:
5551 m_value.valueID = CSSValueCompact;
5552 break;
5553 default:
5554 ASSERT_NOT_REACHED();
5555 break;
5556 }
5557}
5558
5559template<> inline CSSPrimitiveValue::operator MathStyle() const
5560{
5561 ASSERT(isValueID());
5562 switch (m_value.valueID) {
5563 case CSSValueNormal:
5564 return MathStyle::Normal;
5565 case CSSValueCompact:
5566 return MathStyle::Compact;
5567 default:
5568 break;
5569 }
5570 ASSERT_NOT_REACHED();
5571 return MathStyle::Normal;
5572}
5573
5574template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ContainerType containerType)
5575 : CSSValue(PrimitiveClass)
5576{
5577 setPrimitiveUnitType(CSSUnitType::CSS_VALUE_ID);
5578 switch (containerType) {
5579 case ContainerType::None:
5580 m_value.valueID = CSSValueNone;
5581 break;
5582 case ContainerType::Size:
5583 m_value.valueID = CSSValueSize;
5584 break;
5585 case ContainerType::InlineSize:
5586 m_value.valueID = CSSValueInlineSize;
5587 break;
5588 }
5589}
5590
5591template<> inline CSSPrimitiveValue::operator ContainerType() const
5592{
5593 ASSERT(isValueID());
5594 switch (m_value.valueID) {
5595 case CSSValueNone:
5596 return ContainerType::None;
5597 case CSSValueSize:
5598 return ContainerType::Size;
5599 case CSSValueInlineSize:
5600 return ContainerType::InlineSize;
5601 default:
5602 break;
5603 }
5604 ASSERT_NOT_REACHED();
5605 return ContainerType::None;
5606}
5607
5608}
Note: See TracBrowser for help on using the repository browser.