OLD | NEW |
1 /* | 1 /* |
2 * Copyright (C) 2007 Alexey Proskuryakov <ap@nypop.com>. | 2 * Copyright (C) 2007 Alexey Proskuryakov <ap@nypop.com>. |
3 * Copyright (C) 2008, 2009, 2010, 2011 Apple Inc. All rights reserved. | 3 * Copyright (C) 2008, 2009, 2010, 2011 Apple Inc. All rights reserved. |
4 * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. | 4 * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. |
5 * (http://www.torchmobile.com/) | 5 * (http://www.torchmobile.com/) |
6 * Copyright (C) 2009 Jeff Schiller <codedread@gmail.com> | 6 * Copyright (C) 2009 Jeff Schiller <codedread@gmail.com> |
7 * Copyright (C) Research In Motion Limited 2010. All rights reserved. | 7 * Copyright (C) Research In Motion Limited 2010. All rights reserved. |
8 * | 8 * |
9 * Redistribution and use in source and binary forms, with or without | 9 * Redistribution and use in source and binary forms, with or without |
10 * modification, are permitted provided that the following conditions | 10 * modification, are permitted provided that the following conditions |
(...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
50 #include "platform/text/TextRun.h" | 50 #include "platform/text/TextRun.h" |
51 #include "platform/text/WritingMode.h" | 51 #include "platform/text/WritingMode.h" |
52 #include "public/platform/WebBlendMode.h" | 52 #include "public/platform/WebBlendMode.h" |
53 #include "wtf/MathExtras.h" | 53 #include "wtf/MathExtras.h" |
54 | 54 |
55 namespace blink { | 55 namespace blink { |
56 | 56 |
57 // TODO(sashab): Move these to CSSPrimitiveValue.h. | 57 // TODO(sashab): Move these to CSSPrimitiveValue.h. |
58 template <> | 58 template <> |
59 inline short CSSPrimitiveValue::convertTo() const { | 59 inline short CSSPrimitiveValue::convertTo() const { |
60 ASSERT(isNumber()); | 60 DCHECK(isNumber()); |
61 return clampTo<short>(getDoubleValue()); | 61 return clampTo<short>(getDoubleValue()); |
62 } | 62 } |
63 | 63 |
64 template <> | 64 template <> |
65 inline unsigned short CSSPrimitiveValue::convertTo() const { | 65 inline unsigned short CSSPrimitiveValue::convertTo() const { |
66 ASSERT(isNumber()); | 66 DCHECK(isNumber()); |
67 return clampTo<unsigned short>(getDoubleValue()); | 67 return clampTo<unsigned short>(getDoubleValue()); |
68 } | 68 } |
69 | 69 |
70 template <> | 70 template <> |
71 inline int CSSPrimitiveValue::convertTo() const { | 71 inline int CSSPrimitiveValue::convertTo() const { |
72 ASSERT(isNumber()); | 72 DCHECK(isNumber()); |
73 return clampTo<int>(getDoubleValue()); | 73 return clampTo<int>(getDoubleValue()); |
74 } | 74 } |
75 | 75 |
76 template <> | 76 template <> |
77 inline unsigned CSSPrimitiveValue::convertTo() const { | 77 inline unsigned CSSPrimitiveValue::convertTo() const { |
78 ASSERT(isNumber()); | 78 DCHECK(isNumber()); |
79 return clampTo<unsigned>(getDoubleValue()); | 79 return clampTo<unsigned>(getDoubleValue()); |
80 } | 80 } |
81 | 81 |
82 template <> | 82 template <> |
83 inline float CSSPrimitiveValue::convertTo() const { | 83 inline float CSSPrimitiveValue::convertTo() const { |
84 ASSERT(isNumber()); | 84 DCHECK(isNumber()); |
85 return clampTo<float>(getDoubleValue()); | 85 return clampTo<float>(getDoubleValue()); |
86 } | 86 } |
87 | 87 |
88 template <> | 88 template <> |
89 inline CSSPrimitiveValue::CSSPrimitiveValue(LineClampValue i) | 89 inline CSSPrimitiveValue::CSSPrimitiveValue(LineClampValue i) |
90 : CSSValue(PrimitiveClass) { | 90 : CSSValue(PrimitiveClass) { |
91 init(i.isPercentage() ? UnitType::Percentage : UnitType::Integer); | 91 init(i.isPercentage() ? UnitType::Percentage : UnitType::Integer); |
92 m_value.num = static_cast<double>(i.value()); | 92 m_value.num = static_cast<double>(i.value()); |
93 } | 93 } |
94 | 94 |
95 template <> | 95 template <> |
96 inline LineClampValue CSSPrimitiveValue::convertTo() const { | 96 inline LineClampValue CSSPrimitiveValue::convertTo() const { |
97 if (type() == UnitType::Integer) | 97 if (type() == UnitType::Integer) |
98 return LineClampValue(clampTo<int>(m_value.num), LineClampLineCount); | 98 return LineClampValue(clampTo<int>(m_value.num), LineClampLineCount); |
99 | 99 |
100 if (type() == UnitType::Percentage) | 100 if (type() == UnitType::Percentage) |
101 return LineClampValue(clampTo<int>(m_value.num), LineClampPercentage); | 101 return LineClampValue(clampTo<int>(m_value.num), LineClampPercentage); |
102 | 102 |
103 ASSERT_NOT_REACHED(); | 103 NOTREACHED(); |
104 return LineClampValue(); | 104 return LineClampValue(); |
105 } | 105 } |
106 | 106 |
107 // TODO(sashab): Move these to CSSIdentifierValueMappings.h, and update to use | 107 // TODO(sashab): Move these to CSSIdentifierValueMappings.h, and update to use |
108 // the CSSValuePool. | 108 // the CSSValuePool. |
109 template <> | 109 template <> |
110 inline CSSIdentifierValue::CSSIdentifierValue(CSSReflectionDirection e) | 110 inline CSSIdentifierValue::CSSIdentifierValue(CSSReflectionDirection e) |
111 : CSSValue(IdentifierClass) { | 111 : CSSValue(IdentifierClass) { |
112 switch (e) { | 112 switch (e) { |
113 case ReflectionAbove: | 113 case ReflectionAbove: |
(...skipping 18 matching lines...) Expand all Loading... |
132 case CSSValueBelow: | 132 case CSSValueBelow: |
133 return ReflectionBelow; | 133 return ReflectionBelow; |
134 case CSSValueLeft: | 134 case CSSValueLeft: |
135 return ReflectionLeft; | 135 return ReflectionLeft; |
136 case CSSValueRight: | 136 case CSSValueRight: |
137 return ReflectionRight; | 137 return ReflectionRight; |
138 default: | 138 default: |
139 break; | 139 break; |
140 } | 140 } |
141 | 141 |
142 ASSERT_NOT_REACHED(); | 142 NOTREACHED(); |
143 return ReflectionBelow; | 143 return ReflectionBelow; |
144 } | 144 } |
145 | 145 |
146 template <> | 146 template <> |
147 inline CSSIdentifierValue::CSSIdentifierValue(ColumnFill columnFill) | 147 inline CSSIdentifierValue::CSSIdentifierValue(ColumnFill columnFill) |
148 : CSSValue(IdentifierClass) { | 148 : CSSValue(IdentifierClass) { |
149 switch (columnFill) { | 149 switch (columnFill) { |
150 case ColumnFillAuto: | 150 case ColumnFillAuto: |
151 m_valueID = CSSValueAuto; | 151 m_valueID = CSSValueAuto; |
152 break; | 152 break; |
153 case ColumnFillBalance: | 153 case ColumnFillBalance: |
154 m_valueID = CSSValueBalance; | 154 m_valueID = CSSValueBalance; |
155 break; | 155 break; |
156 } | 156 } |
157 } | 157 } |
158 | 158 |
159 template <> | 159 template <> |
160 inline ColumnFill CSSIdentifierValue::convertTo() const { | 160 inline ColumnFill CSSIdentifierValue::convertTo() const { |
161 if (m_valueID == CSSValueBalance) | 161 if (m_valueID == CSSValueBalance) |
162 return ColumnFillBalance; | 162 return ColumnFillBalance; |
163 if (m_valueID == CSSValueAuto) | 163 if (m_valueID == CSSValueAuto) |
164 return ColumnFillAuto; | 164 return ColumnFillAuto; |
165 ASSERT_NOT_REACHED(); | 165 NOTREACHED(); |
166 return ColumnFillBalance; | 166 return ColumnFillBalance; |
167 } | 167 } |
168 | 168 |
169 template <> | 169 template <> |
170 inline CSSIdentifierValue::CSSIdentifierValue(ColumnSpan columnSpan) | 170 inline CSSIdentifierValue::CSSIdentifierValue(ColumnSpan columnSpan) |
171 : CSSValue(IdentifierClass) { | 171 : CSSValue(IdentifierClass) { |
172 switch (columnSpan) { | 172 switch (columnSpan) { |
173 case ColumnSpanAll: | 173 case ColumnSpanAll: |
174 m_valueID = CSSValueAll; | 174 m_valueID = CSSValueAll; |
175 break; | 175 break; |
176 case ColumnSpanNone: | 176 case ColumnSpanNone: |
177 m_valueID = CSSValueNone; | 177 m_valueID = CSSValueNone; |
178 break; | 178 break; |
179 } | 179 } |
180 } | 180 } |
181 | 181 |
182 template <> | 182 template <> |
183 inline ColumnSpan CSSIdentifierValue::convertTo() const { | 183 inline ColumnSpan CSSIdentifierValue::convertTo() const { |
184 switch (m_valueID) { | 184 switch (m_valueID) { |
185 case CSSValueAll: | 185 case CSSValueAll: |
186 return ColumnSpanAll; | 186 return ColumnSpanAll; |
187 default: | 187 default: |
188 ASSERT_NOT_REACHED(); | 188 NOTREACHED(); |
189 // fall-through | 189 // fall-through |
190 case CSSValueNone: | 190 case CSSValueNone: |
191 return ColumnSpanNone; | 191 return ColumnSpanNone; |
192 } | 192 } |
193 } | 193 } |
194 | 194 |
195 template <> | 195 template <> |
196 inline CSSIdentifierValue::CSSIdentifierValue(EBorderStyle e) | 196 inline CSSIdentifierValue::CSSIdentifierValue(EBorderStyle e) |
197 : CSSValue(IdentifierClass) { | 197 : CSSValue(IdentifierClass) { |
198 switch (e) { | 198 switch (e) { |
(...skipping 78 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
277 case CompositeDestinationAtop: | 277 case CompositeDestinationAtop: |
278 m_valueID = CSSValueDestinationAtop; | 278 m_valueID = CSSValueDestinationAtop; |
279 break; | 279 break; |
280 case CompositeXOR: | 280 case CompositeXOR: |
281 m_valueID = CSSValueXor; | 281 m_valueID = CSSValueXor; |
282 break; | 282 break; |
283 case CompositePlusLighter: | 283 case CompositePlusLighter: |
284 m_valueID = CSSValuePlusLighter; | 284 m_valueID = CSSValuePlusLighter; |
285 break; | 285 break; |
286 default: | 286 default: |
287 ASSERT_NOT_REACHED(); | 287 NOTREACHED(); |
288 break; | 288 break; |
289 } | 289 } |
290 } | 290 } |
291 | 291 |
292 template <> | 292 template <> |
293 inline CompositeOperator CSSIdentifierValue::convertTo() const { | 293 inline CompositeOperator CSSIdentifierValue::convertTo() const { |
294 switch (m_valueID) { | 294 switch (m_valueID) { |
295 case CSSValueClear: | 295 case CSSValueClear: |
296 return CompositeClear; | 296 return CompositeClear; |
297 case CSSValueCopy: | 297 case CSSValueCopy: |
(...skipping 15 matching lines...) Expand all Loading... |
313 case CSSValueDestinationAtop: | 313 case CSSValueDestinationAtop: |
314 return CompositeDestinationAtop; | 314 return CompositeDestinationAtop; |
315 case CSSValueXor: | 315 case CSSValueXor: |
316 return CompositeXOR; | 316 return CompositeXOR; |
317 case CSSValuePlusLighter: | 317 case CSSValuePlusLighter: |
318 return CompositePlusLighter; | 318 return CompositePlusLighter; |
319 default: | 319 default: |
320 break; | 320 break; |
321 } | 321 } |
322 | 322 |
323 ASSERT_NOT_REACHED(); | 323 NOTREACHED(); |
324 return CompositeClear; | 324 return CompositeClear; |
325 } | 325 } |
326 | 326 |
327 template <> | 327 template <> |
328 inline CSSIdentifierValue::CSSIdentifierValue(ControlPart e) | 328 inline CSSIdentifierValue::CSSIdentifierValue(ControlPart e) |
329 : CSSValue(IdentifierClass) { | 329 : CSSValue(IdentifierClass) { |
330 switch (e) { | 330 switch (e) { |
331 case NoControlPart: | 331 case NoControlPart: |
332 m_valueID = CSSValueNone; | 332 m_valueID = CSSValueNone; |
333 break; | 333 break; |
(...skipping 174 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
508 inline EBackfaceVisibility CSSIdentifierValue::convertTo() const { | 508 inline EBackfaceVisibility CSSIdentifierValue::convertTo() const { |
509 switch (m_valueID) { | 509 switch (m_valueID) { |
510 case CSSValueVisible: | 510 case CSSValueVisible: |
511 return BackfaceVisibilityVisible; | 511 return BackfaceVisibilityVisible; |
512 case CSSValueHidden: | 512 case CSSValueHidden: |
513 return BackfaceVisibilityHidden; | 513 return BackfaceVisibilityHidden; |
514 default: | 514 default: |
515 break; | 515 break; |
516 } | 516 } |
517 | 517 |
518 ASSERT_NOT_REACHED(); | 518 NOTREACHED(); |
519 return BackfaceVisibilityHidden; | 519 return BackfaceVisibilityHidden; |
520 } | 520 } |
521 | 521 |
522 template <> | 522 template <> |
523 inline CSSIdentifierValue::CSSIdentifierValue(EFillAttachment e) | 523 inline CSSIdentifierValue::CSSIdentifierValue(EFillAttachment e) |
524 : CSSValue(IdentifierClass) { | 524 : CSSValue(IdentifierClass) { |
525 switch (e) { | 525 switch (e) { |
526 case ScrollBackgroundAttachment: | 526 case ScrollBackgroundAttachment: |
527 m_valueID = CSSValueScroll; | 527 m_valueID = CSSValueScroll; |
528 break; | 528 break; |
(...skipping 12 matching lines...) Expand all Loading... |
541 case CSSValueScroll: | 541 case CSSValueScroll: |
542 return ScrollBackgroundAttachment; | 542 return ScrollBackgroundAttachment; |
543 case CSSValueLocal: | 543 case CSSValueLocal: |
544 return LocalBackgroundAttachment; | 544 return LocalBackgroundAttachment; |
545 case CSSValueFixed: | 545 case CSSValueFixed: |
546 return FixedBackgroundAttachment; | 546 return FixedBackgroundAttachment; |
547 default: | 547 default: |
548 break; | 548 break; |
549 } | 549 } |
550 | 550 |
551 ASSERT_NOT_REACHED(); | 551 NOTREACHED(); |
552 return ScrollBackgroundAttachment; | 552 return ScrollBackgroundAttachment; |
553 } | 553 } |
554 | 554 |
555 template <> | 555 template <> |
556 inline CSSIdentifierValue::CSSIdentifierValue(EFillBox e) | 556 inline CSSIdentifierValue::CSSIdentifierValue(EFillBox e) |
557 : CSSValue(IdentifierClass) { | 557 : CSSValue(IdentifierClass) { |
558 switch (e) { | 558 switch (e) { |
559 case BorderFillBox: | 559 case BorderFillBox: |
560 m_valueID = CSSValueBorderBox; | 560 m_valueID = CSSValueBorderBox; |
561 break; | 561 break; |
(...skipping 20 matching lines...) Expand all Loading... |
582 return PaddingFillBox; | 582 return PaddingFillBox; |
583 case CSSValueContent: | 583 case CSSValueContent: |
584 case CSSValueContentBox: | 584 case CSSValueContentBox: |
585 return ContentFillBox; | 585 return ContentFillBox; |
586 case CSSValueText: | 586 case CSSValueText: |
587 return TextFillBox; | 587 return TextFillBox; |
588 default: | 588 default: |
589 break; | 589 break; |
590 } | 590 } |
591 | 591 |
592 ASSERT_NOT_REACHED(); | 592 NOTREACHED(); |
593 return BorderFillBox; | 593 return BorderFillBox; |
594 } | 594 } |
595 | 595 |
596 template <> | 596 template <> |
597 inline CSSIdentifierValue::CSSIdentifierValue(EFillRepeat e) | 597 inline CSSIdentifierValue::CSSIdentifierValue(EFillRepeat e) |
598 : CSSValue(IdentifierClass) { | 598 : CSSValue(IdentifierClass) { |
599 switch (e) { | 599 switch (e) { |
600 case RepeatFill: | 600 case RepeatFill: |
601 m_valueID = CSSValueRepeat; | 601 m_valueID = CSSValueRepeat; |
602 break; | 602 break; |
(...skipping 17 matching lines...) Expand all Loading... |
620 case CSSValueNoRepeat: | 620 case CSSValueNoRepeat: |
621 return NoRepeatFill; | 621 return NoRepeatFill; |
622 case CSSValueRound: | 622 case CSSValueRound: |
623 return RoundFill; | 623 return RoundFill; |
624 case CSSValueSpace: | 624 case CSSValueSpace: |
625 return SpaceFill; | 625 return SpaceFill; |
626 default: | 626 default: |
627 break; | 627 break; |
628 } | 628 } |
629 | 629 |
630 ASSERT_NOT_REACHED(); | 630 NOTREACHED(); |
631 return RepeatFill; | 631 return RepeatFill; |
632 } | 632 } |
633 | 633 |
634 template <> | 634 template <> |
635 inline CSSIdentifierValue::CSSIdentifierValue(EBoxPack e) | 635 inline CSSIdentifierValue::CSSIdentifierValue(EBoxPack e) |
636 : CSSValue(IdentifierClass) { | 636 : CSSValue(IdentifierClass) { |
637 switch (e) { | 637 switch (e) { |
638 case BoxPackStart: | 638 case BoxPackStart: |
639 m_valueID = CSSValueStart; | 639 m_valueID = CSSValueStart; |
640 break; | 640 break; |
(...skipping 17 matching lines...) Expand all Loading... |
658 case CSSValueEnd: | 658 case CSSValueEnd: |
659 return BoxPackEnd; | 659 return BoxPackEnd; |
660 case CSSValueCenter: | 660 case CSSValueCenter: |
661 return BoxPackCenter; | 661 return BoxPackCenter; |
662 case CSSValueJustify: | 662 case CSSValueJustify: |
663 return BoxPackJustify; | 663 return BoxPackJustify; |
664 default: | 664 default: |
665 break; | 665 break; |
666 } | 666 } |
667 | 667 |
668 ASSERT_NOT_REACHED(); | 668 NOTREACHED(); |
669 return BoxPackJustify; | 669 return BoxPackJustify; |
670 } | 670 } |
671 | 671 |
672 template <> | 672 template <> |
673 inline CSSIdentifierValue::CSSIdentifierValue(EBoxAlignment e) | 673 inline CSSIdentifierValue::CSSIdentifierValue(EBoxAlignment e) |
674 : CSSValue(IdentifierClass) { | 674 : CSSValue(IdentifierClass) { |
675 switch (e) { | 675 switch (e) { |
676 case BSTRETCH: | 676 case BSTRETCH: |
677 m_valueID = CSSValueStretch; | 677 m_valueID = CSSValueStretch; |
678 break; | 678 break; |
(...skipping 22 matching lines...) Expand all Loading... |
701 case CSSValueEnd: | 701 case CSSValueEnd: |
702 return BEND; | 702 return BEND; |
703 case CSSValueCenter: | 703 case CSSValueCenter: |
704 return BCENTER; | 704 return BCENTER; |
705 case CSSValueBaseline: | 705 case CSSValueBaseline: |
706 return BBASELINE; | 706 return BBASELINE; |
707 default: | 707 default: |
708 break; | 708 break; |
709 } | 709 } |
710 | 710 |
711 ASSERT_NOT_REACHED(); | 711 NOTREACHED(); |
712 return BSTRETCH; | 712 return BSTRETCH; |
713 } | 713 } |
714 | 714 |
715 template <> | 715 template <> |
716 inline CSSIdentifierValue::CSSIdentifierValue(EBoxDecorationBreak e) | 716 inline CSSIdentifierValue::CSSIdentifierValue(EBoxDecorationBreak e) |
717 : CSSValue(IdentifierClass) { | 717 : CSSValue(IdentifierClass) { |
718 switch (e) { | 718 switch (e) { |
719 case BoxDecorationBreakSlice: | 719 case BoxDecorationBreakSlice: |
720 m_valueID = CSSValueSlice; | 720 m_valueID = CSSValueSlice; |
721 break; | 721 break; |
722 case BoxDecorationBreakClone: | 722 case BoxDecorationBreakClone: |
723 m_valueID = CSSValueClone; | 723 m_valueID = CSSValueClone; |
724 break; | 724 break; |
725 } | 725 } |
726 } | 726 } |
727 | 727 |
728 template <> | 728 template <> |
729 inline EBoxDecorationBreak CSSIdentifierValue::convertTo() const { | 729 inline EBoxDecorationBreak CSSIdentifierValue::convertTo() const { |
730 switch (m_valueID) { | 730 switch (m_valueID) { |
731 case CSSValueSlice: | 731 case CSSValueSlice: |
732 return BoxDecorationBreakSlice; | 732 return BoxDecorationBreakSlice; |
733 case CSSValueClone: | 733 case CSSValueClone: |
734 return BoxDecorationBreakClone; | 734 return BoxDecorationBreakClone; |
735 default: | 735 default: |
736 break; | 736 break; |
737 } | 737 } |
738 | 738 |
739 ASSERT_NOT_REACHED(); | 739 NOTREACHED(); |
740 return BoxDecorationBreakSlice; | 740 return BoxDecorationBreakSlice; |
741 } | 741 } |
742 | 742 |
743 template <> | 743 template <> |
744 inline CSSIdentifierValue::CSSIdentifierValue(BackgroundEdgeOrigin e) | 744 inline CSSIdentifierValue::CSSIdentifierValue(BackgroundEdgeOrigin e) |
745 : CSSValue(IdentifierClass) { | 745 : CSSValue(IdentifierClass) { |
746 switch (e) { | 746 switch (e) { |
747 case TopEdge: | 747 case TopEdge: |
748 m_valueID = CSSValueTop; | 748 m_valueID = CSSValueTop; |
749 break; | 749 break; |
(...skipping 17 matching lines...) Expand all Loading... |
767 case CSSValueRight: | 767 case CSSValueRight: |
768 return RightEdge; | 768 return RightEdge; |
769 case CSSValueBottom: | 769 case CSSValueBottom: |
770 return BottomEdge; | 770 return BottomEdge; |
771 case CSSValueLeft: | 771 case CSSValueLeft: |
772 return LeftEdge; | 772 return LeftEdge; |
773 default: | 773 default: |
774 break; | 774 break; |
775 } | 775 } |
776 | 776 |
777 ASSERT_NOT_REACHED(); | 777 NOTREACHED(); |
778 return TopEdge; | 778 return TopEdge; |
779 } | 779 } |
780 | 780 |
781 template <> | 781 template <> |
782 inline CSSIdentifierValue::CSSIdentifierValue(EBoxSizing e) | 782 inline CSSIdentifierValue::CSSIdentifierValue(EBoxSizing e) |
783 : CSSValue(IdentifierClass) { | 783 : CSSValue(IdentifierClass) { |
784 switch (e) { | 784 switch (e) { |
785 case EBoxSizing::kBorderBox: | 785 case EBoxSizing::kBorderBox: |
786 m_valueID = CSSValueBorderBox; | 786 m_valueID = CSSValueBorderBox; |
787 break; | 787 break; |
788 case EBoxSizing::kContentBox: | 788 case EBoxSizing::kContentBox: |
789 m_valueID = CSSValueContentBox; | 789 m_valueID = CSSValueContentBox; |
790 break; | 790 break; |
791 } | 791 } |
792 } | 792 } |
793 | 793 |
794 template <> | 794 template <> |
795 inline EBoxSizing CSSIdentifierValue::convertTo() const { | 795 inline EBoxSizing CSSIdentifierValue::convertTo() const { |
796 switch (m_valueID) { | 796 switch (m_valueID) { |
797 case CSSValueBorderBox: | 797 case CSSValueBorderBox: |
798 return EBoxSizing::kBorderBox; | 798 return EBoxSizing::kBorderBox; |
799 case CSSValueContentBox: | 799 case CSSValueContentBox: |
800 return EBoxSizing::kContentBox; | 800 return EBoxSizing::kContentBox; |
801 default: | 801 default: |
802 break; | 802 break; |
803 } | 803 } |
804 | 804 |
805 ASSERT_NOT_REACHED(); | 805 NOTREACHED(); |
806 return EBoxSizing::kBorderBox; | 806 return EBoxSizing::kBorderBox; |
807 } | 807 } |
808 | 808 |
809 template <> | 809 template <> |
810 inline CSSIdentifierValue::CSSIdentifierValue(EBoxLines e) | 810 inline CSSIdentifierValue::CSSIdentifierValue(EBoxLines e) |
811 : CSSValue(IdentifierClass) { | 811 : CSSValue(IdentifierClass) { |
812 switch (e) { | 812 switch (e) { |
813 case SINGLE: | 813 case SINGLE: |
814 m_valueID = CSSValueSingle; | 814 m_valueID = CSSValueSingle; |
815 break; | 815 break; |
816 case MULTIPLE: | 816 case MULTIPLE: |
817 m_valueID = CSSValueMultiple; | 817 m_valueID = CSSValueMultiple; |
818 break; | 818 break; |
819 } | 819 } |
820 } | 820 } |
821 | 821 |
822 template <> | 822 template <> |
823 inline EBoxLines CSSIdentifierValue::convertTo() const { | 823 inline EBoxLines CSSIdentifierValue::convertTo() const { |
824 switch (m_valueID) { | 824 switch (m_valueID) { |
825 case CSSValueSingle: | 825 case CSSValueSingle: |
826 return SINGLE; | 826 return SINGLE; |
827 case CSSValueMultiple: | 827 case CSSValueMultiple: |
828 return MULTIPLE; | 828 return MULTIPLE; |
829 default: | 829 default: |
830 break; | 830 break; |
831 } | 831 } |
832 | 832 |
833 ASSERT_NOT_REACHED(); | 833 NOTREACHED(); |
834 return SINGLE; | 834 return SINGLE; |
835 } | 835 } |
836 | 836 |
837 template <> | 837 template <> |
838 inline CSSIdentifierValue::CSSIdentifierValue(EBoxOrient e) | 838 inline CSSIdentifierValue::CSSIdentifierValue(EBoxOrient e) |
839 : CSSValue(IdentifierClass) { | 839 : CSSValue(IdentifierClass) { |
840 switch (e) { | 840 switch (e) { |
841 case HORIZONTAL: | 841 case HORIZONTAL: |
842 m_valueID = CSSValueHorizontal; | 842 m_valueID = CSSValueHorizontal; |
843 break; | 843 break; |
844 case VERTICAL: | 844 case VERTICAL: |
845 m_valueID = CSSValueVertical; | 845 m_valueID = CSSValueVertical; |
846 break; | 846 break; |
847 } | 847 } |
848 } | 848 } |
849 | 849 |
850 template <> | 850 template <> |
851 inline EBoxOrient CSSIdentifierValue::convertTo() const { | 851 inline EBoxOrient CSSIdentifierValue::convertTo() const { |
852 switch (m_valueID) { | 852 switch (m_valueID) { |
853 case CSSValueHorizontal: | 853 case CSSValueHorizontal: |
854 case CSSValueInlineAxis: | 854 case CSSValueInlineAxis: |
855 return HORIZONTAL; | 855 return HORIZONTAL; |
856 case CSSValueVertical: | 856 case CSSValueVertical: |
857 case CSSValueBlockAxis: | 857 case CSSValueBlockAxis: |
858 return VERTICAL; | 858 return VERTICAL; |
859 default: | 859 default: |
860 break; | 860 break; |
861 } | 861 } |
862 | 862 |
863 ASSERT_NOT_REACHED(); | 863 NOTREACHED(); |
864 return HORIZONTAL; | 864 return HORIZONTAL; |
865 } | 865 } |
866 | 866 |
867 template <> | 867 template <> |
868 inline CSSIdentifierValue::CSSIdentifierValue(ECursor e) | 868 inline CSSIdentifierValue::CSSIdentifierValue(ECursor e) |
869 : CSSValue(IdentifierClass) { | 869 : CSSValue(IdentifierClass) { |
870 switch (e) { | 870 switch (e) { |
871 case ECursor::kAuto: | 871 case ECursor::kAuto: |
872 m_valueID = CSSValueAuto; | 872 m_valueID = CSSValueAuto; |
873 break; | 873 break; |
(...skipping 349 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1223 case CSSValueRowReverse: | 1223 case CSSValueRowReverse: |
1224 return FlowRowReverse; | 1224 return FlowRowReverse; |
1225 case CSSValueColumn: | 1225 case CSSValueColumn: |
1226 return FlowColumn; | 1226 return FlowColumn; |
1227 case CSSValueColumnReverse: | 1227 case CSSValueColumnReverse: |
1228 return FlowColumnReverse; | 1228 return FlowColumnReverse; |
1229 default: | 1229 default: |
1230 break; | 1230 break; |
1231 } | 1231 } |
1232 | 1232 |
1233 ASSERT_NOT_REACHED(); | 1233 NOTREACHED(); |
1234 return FlowRow; | 1234 return FlowRow; |
1235 } | 1235 } |
1236 | 1236 |
1237 template <> | 1237 template <> |
1238 inline CSSIdentifierValue::CSSIdentifierValue(EFlexWrap e) | 1238 inline CSSIdentifierValue::CSSIdentifierValue(EFlexWrap e) |
1239 : CSSValue(IdentifierClass) { | 1239 : CSSValue(IdentifierClass) { |
1240 switch (e) { | 1240 switch (e) { |
1241 case FlexNoWrap: | 1241 case FlexNoWrap: |
1242 m_valueID = CSSValueNowrap; | 1242 m_valueID = CSSValueNowrap; |
1243 break; | 1243 break; |
(...skipping 12 matching lines...) Expand all Loading... |
1256 case CSSValueNowrap: | 1256 case CSSValueNowrap: |
1257 return FlexNoWrap; | 1257 return FlexNoWrap; |
1258 case CSSValueWrap: | 1258 case CSSValueWrap: |
1259 return FlexWrap; | 1259 return FlexWrap; |
1260 case CSSValueWrapReverse: | 1260 case CSSValueWrapReverse: |
1261 return FlexWrapReverse; | 1261 return FlexWrapReverse; |
1262 default: | 1262 default: |
1263 break; | 1263 break; |
1264 } | 1264 } |
1265 | 1265 |
1266 ASSERT_NOT_REACHED(); | 1266 NOTREACHED(); |
1267 return FlexNoWrap; | 1267 return FlexNoWrap; |
1268 } | 1268 } |
1269 | 1269 |
1270 template <> | 1270 template <> |
1271 inline CSSIdentifierValue::CSSIdentifierValue(EFloat e) | 1271 inline CSSIdentifierValue::CSSIdentifierValue(EFloat e) |
1272 : CSSValue(IdentifierClass) { | 1272 : CSSValue(IdentifierClass) { |
1273 switch (e) { | 1273 switch (e) { |
1274 case EFloat::kNone: | 1274 case EFloat::kNone: |
1275 m_valueID = CSSValueNone; | 1275 m_valueID = CSSValueNone; |
1276 break; | 1276 break; |
(...skipping 12 matching lines...) Expand all Loading... |
1289 case CSSValueLeft: | 1289 case CSSValueLeft: |
1290 return EFloat::kLeft; | 1290 return EFloat::kLeft; |
1291 case CSSValueRight: | 1291 case CSSValueRight: |
1292 return EFloat::kRight; | 1292 return EFloat::kRight; |
1293 case CSSValueNone: | 1293 case CSSValueNone: |
1294 return EFloat::kNone; | 1294 return EFloat::kNone; |
1295 default: | 1295 default: |
1296 break; | 1296 break; |
1297 } | 1297 } |
1298 | 1298 |
1299 ASSERT_NOT_REACHED(); | 1299 NOTREACHED(); |
1300 return EFloat::kNone; | 1300 return EFloat::kNone; |
1301 } | 1301 } |
1302 | 1302 |
1303 template <> | 1303 template <> |
1304 inline CSSIdentifierValue::CSSIdentifierValue(Hyphens e) | 1304 inline CSSIdentifierValue::CSSIdentifierValue(Hyphens e) |
1305 : CSSValue(IdentifierClass) { | 1305 : CSSValue(IdentifierClass) { |
1306 switch (e) { | 1306 switch (e) { |
1307 case HyphensAuto: | 1307 case HyphensAuto: |
1308 m_valueID = CSSValueAuto; | 1308 m_valueID = CSSValueAuto; |
1309 break; | 1309 break; |
(...skipping 55 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1365 case CSSValueNormal: | 1365 case CSSValueNormal: |
1366 return LineBreakNormal; | 1366 return LineBreakNormal; |
1367 case CSSValueStrict: | 1367 case CSSValueStrict: |
1368 return LineBreakStrict; | 1368 return LineBreakStrict; |
1369 case CSSValueAfterWhiteSpace: | 1369 case CSSValueAfterWhiteSpace: |
1370 return LineBreakAfterWhiteSpace; | 1370 return LineBreakAfterWhiteSpace; |
1371 default: | 1371 default: |
1372 break; | 1372 break; |
1373 } | 1373 } |
1374 | 1374 |
1375 ASSERT_NOT_REACHED(); | 1375 NOTREACHED(); |
1376 return LineBreakAuto; | 1376 return LineBreakAuto; |
1377 } | 1377 } |
1378 | 1378 |
1379 template <> | 1379 template <> |
1380 inline CSSIdentifierValue::CSSIdentifierValue(EMarginCollapse e) | 1380 inline CSSIdentifierValue::CSSIdentifierValue(EMarginCollapse e) |
1381 : CSSValue(IdentifierClass) { | 1381 : CSSValue(IdentifierClass) { |
1382 switch (e) { | 1382 switch (e) { |
1383 case MarginCollapseCollapse: | 1383 case MarginCollapseCollapse: |
1384 m_valueID = CSSValueCollapse; | 1384 m_valueID = CSSValueCollapse; |
1385 break; | 1385 break; |
(...skipping 55 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1441 case CSSValueAbsolute: | 1441 case CSSValueAbsolute: |
1442 return EPosition::kAbsolute; | 1442 return EPosition::kAbsolute; |
1443 case CSSValueFixed: | 1443 case CSSValueFixed: |
1444 return EPosition::kFixed; | 1444 return EPosition::kFixed; |
1445 case CSSValueSticky: | 1445 case CSSValueSticky: |
1446 return EPosition::kSticky; | 1446 return EPosition::kSticky; |
1447 default: | 1447 default: |
1448 break; | 1448 break; |
1449 } | 1449 } |
1450 | 1450 |
1451 ASSERT_NOT_REACHED(); | 1451 NOTREACHED(); |
1452 return EPosition::kStatic; | 1452 return EPosition::kStatic; |
1453 } | 1453 } |
1454 | 1454 |
1455 template <> | 1455 template <> |
1456 inline CSSIdentifierValue::CSSIdentifierValue(EResize e) | 1456 inline CSSIdentifierValue::CSSIdentifierValue(EResize e) |
1457 : CSSValue(IdentifierClass) { | 1457 : CSSValue(IdentifierClass) { |
1458 switch (e) { | 1458 switch (e) { |
1459 case RESIZE_BOTH: | 1459 case RESIZE_BOTH: |
1460 m_valueID = CSSValueBoth; | 1460 m_valueID = CSSValueBoth; |
1461 break; | 1461 break; |
(...skipping 21 matching lines...) Expand all Loading... |
1483 case CSSValueAuto: | 1483 case CSSValueAuto: |
1484 // Depends on settings, thus should be handled by the caller. | 1484 // Depends on settings, thus should be handled by the caller. |
1485 NOTREACHED(); | 1485 NOTREACHED(); |
1486 return RESIZE_NONE; | 1486 return RESIZE_NONE; |
1487 case CSSValueNone: | 1487 case CSSValueNone: |
1488 return RESIZE_NONE; | 1488 return RESIZE_NONE; |
1489 default: | 1489 default: |
1490 break; | 1490 break; |
1491 } | 1491 } |
1492 | 1492 |
1493 ASSERT_NOT_REACHED(); | 1493 NOTREACHED(); |
1494 return RESIZE_NONE; | 1494 return RESIZE_NONE; |
1495 } | 1495 } |
1496 | 1496 |
1497 template <> | 1497 template <> |
1498 inline CSSIdentifierValue::CSSIdentifierValue(ETableLayout e) | 1498 inline CSSIdentifierValue::CSSIdentifierValue(ETableLayout e) |
1499 : CSSValue(IdentifierClass) { | 1499 : CSSValue(IdentifierClass) { |
1500 switch (e) { | 1500 switch (e) { |
1501 case ETableLayout::kAuto: | 1501 case ETableLayout::kAuto: |
1502 m_valueID = CSSValueAuto; | 1502 m_valueID = CSSValueAuto; |
1503 break; | 1503 break; |
1504 case ETableLayout::kFixed: | 1504 case ETableLayout::kFixed: |
1505 m_valueID = CSSValueFixed; | 1505 m_valueID = CSSValueFixed; |
1506 break; | 1506 break; |
1507 } | 1507 } |
1508 } | 1508 } |
1509 | 1509 |
1510 template <> | 1510 template <> |
1511 inline ETableLayout CSSIdentifierValue::convertTo() const { | 1511 inline ETableLayout CSSIdentifierValue::convertTo() const { |
1512 switch (m_valueID) { | 1512 switch (m_valueID) { |
1513 case CSSValueFixed: | 1513 case CSSValueFixed: |
1514 return ETableLayout::kFixed; | 1514 return ETableLayout::kFixed; |
1515 case CSSValueAuto: | 1515 case CSSValueAuto: |
1516 return ETableLayout::kAuto; | 1516 return ETableLayout::kAuto; |
1517 default: | 1517 default: |
1518 break; | 1518 break; |
1519 } | 1519 } |
1520 | 1520 |
1521 ASSERT_NOT_REACHED(); | 1521 NOTREACHED(); |
1522 return ETableLayout::kAuto; | 1522 return ETableLayout::kAuto; |
1523 } | 1523 } |
1524 | 1524 |
1525 template <> | 1525 template <> |
1526 inline CSSIdentifierValue::CSSIdentifierValue(TextAlignLast e) | 1526 inline CSSIdentifierValue::CSSIdentifierValue(TextAlignLast e) |
1527 : CSSValue(IdentifierClass) { | 1527 : CSSValue(IdentifierClass) { |
1528 switch (e) { | 1528 switch (e) { |
1529 case TextAlignLastStart: | 1529 case TextAlignLastStart: |
1530 m_valueID = CSSValueStart; | 1530 m_valueID = CSSValueStart; |
1531 break; | 1531 break; |
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1564 case CSSValueRight: | 1564 case CSSValueRight: |
1565 return TextAlignLastRight; | 1565 return TextAlignLastRight; |
1566 case CSSValueCenter: | 1566 case CSSValueCenter: |
1567 return TextAlignLastCenter; | 1567 return TextAlignLastCenter; |
1568 case CSSValueJustify: | 1568 case CSSValueJustify: |
1569 return TextAlignLastJustify; | 1569 return TextAlignLastJustify; |
1570 default: | 1570 default: |
1571 break; | 1571 break; |
1572 } | 1572 } |
1573 | 1573 |
1574 ASSERT_NOT_REACHED(); | 1574 NOTREACHED(); |
1575 return TextAlignLastAuto; | 1575 return TextAlignLastAuto; |
1576 } | 1576 } |
1577 | 1577 |
1578 template <> | 1578 template <> |
1579 inline CSSIdentifierValue::CSSIdentifierValue(TextJustify e) | 1579 inline CSSIdentifierValue::CSSIdentifierValue(TextJustify e) |
1580 : CSSValue(IdentifierClass) { | 1580 : CSSValue(IdentifierClass) { |
1581 switch (e) { | 1581 switch (e) { |
1582 case TextJustifyAuto: | 1582 case TextJustifyAuto: |
1583 m_valueID = CSSValueAuto; | 1583 m_valueID = CSSValueAuto; |
1584 break; | 1584 break; |
(...skipping 17 matching lines...) Expand all Loading... |
1602 case CSSValueNone: | 1602 case CSSValueNone: |
1603 return TextJustifyNone; | 1603 return TextJustifyNone; |
1604 case CSSValueInterWord: | 1604 case CSSValueInterWord: |
1605 return TextJustifyInterWord; | 1605 return TextJustifyInterWord; |
1606 case CSSValueDistribute: | 1606 case CSSValueDistribute: |
1607 return TextJustifyDistribute; | 1607 return TextJustifyDistribute; |
1608 default: | 1608 default: |
1609 break; | 1609 break; |
1610 } | 1610 } |
1611 | 1611 |
1612 ASSERT_NOT_REACHED(); | 1612 NOTREACHED(); |
1613 return TextJustifyAuto; | 1613 return TextJustifyAuto; |
1614 } | 1614 } |
1615 | 1615 |
1616 template <> | 1616 template <> |
1617 inline TextDecoration CSSIdentifierValue::convertTo() const { | 1617 inline TextDecoration CSSIdentifierValue::convertTo() const { |
1618 switch (m_valueID) { | 1618 switch (m_valueID) { |
1619 case CSSValueNone: | 1619 case CSSValueNone: |
1620 return TextDecorationNone; | 1620 return TextDecorationNone; |
1621 case CSSValueUnderline: | 1621 case CSSValueUnderline: |
1622 return TextDecorationUnderline; | 1622 return TextDecorationUnderline; |
1623 case CSSValueOverline: | 1623 case CSSValueOverline: |
1624 return TextDecorationOverline; | 1624 return TextDecorationOverline; |
1625 case CSSValueLineThrough: | 1625 case CSSValueLineThrough: |
1626 return TextDecorationLineThrough; | 1626 return TextDecorationLineThrough; |
1627 case CSSValueBlink: | 1627 case CSSValueBlink: |
1628 return TextDecorationBlink; | 1628 return TextDecorationBlink; |
1629 default: | 1629 default: |
1630 break; | 1630 break; |
1631 } | 1631 } |
1632 | 1632 |
1633 ASSERT_NOT_REACHED(); | 1633 NOTREACHED(); |
1634 return TextDecorationNone; | 1634 return TextDecorationNone; |
1635 } | 1635 } |
1636 | 1636 |
1637 template <> | 1637 template <> |
1638 inline TextDecorationStyle CSSIdentifierValue::convertTo() const { | 1638 inline TextDecorationStyle CSSIdentifierValue::convertTo() const { |
1639 switch (m_valueID) { | 1639 switch (m_valueID) { |
1640 case CSSValueSolid: | 1640 case CSSValueSolid: |
1641 return TextDecorationStyleSolid; | 1641 return TextDecorationStyleSolid; |
1642 case CSSValueDouble: | 1642 case CSSValueDouble: |
1643 return TextDecorationStyleDouble; | 1643 return TextDecorationStyleDouble; |
1644 case CSSValueDotted: | 1644 case CSSValueDotted: |
1645 return TextDecorationStyleDotted; | 1645 return TextDecorationStyleDotted; |
1646 case CSSValueDashed: | 1646 case CSSValueDashed: |
1647 return TextDecorationStyleDashed; | 1647 return TextDecorationStyleDashed; |
1648 case CSSValueWavy: | 1648 case CSSValueWavy: |
1649 return TextDecorationStyleWavy; | 1649 return TextDecorationStyleWavy; |
1650 default: | 1650 default: |
1651 break; | 1651 break; |
1652 } | 1652 } |
1653 | 1653 |
1654 ASSERT_NOT_REACHED(); | 1654 NOTREACHED(); |
1655 return TextDecorationStyleSolid; | 1655 return TextDecorationStyleSolid; |
1656 } | 1656 } |
1657 | 1657 |
1658 template <> | 1658 template <> |
1659 inline CSSIdentifierValue::CSSIdentifierValue(TextUnderlinePosition e) | 1659 inline CSSIdentifierValue::CSSIdentifierValue(TextUnderlinePosition e) |
1660 : CSSValue(IdentifierClass) { | 1660 : CSSValue(IdentifierClass) { |
1661 switch (e) { | 1661 switch (e) { |
1662 case TextUnderlinePositionAuto: | 1662 case TextUnderlinePositionAuto: |
1663 m_valueID = CSSValueAuto; | 1663 m_valueID = CSSValueAuto; |
1664 break; | 1664 break; |
(...skipping 11 matching lines...) Expand all Loading... |
1676 case CSSValueAuto: | 1676 case CSSValueAuto: |
1677 return TextUnderlinePositionAuto; | 1677 return TextUnderlinePositionAuto; |
1678 case CSSValueUnder: | 1678 case CSSValueUnder: |
1679 return TextUnderlinePositionUnder; | 1679 return TextUnderlinePositionUnder; |
1680 default: | 1680 default: |
1681 break; | 1681 break; |
1682 } | 1682 } |
1683 | 1683 |
1684 // FIXME: Implement support for 'under left' and 'under right' values. | 1684 // FIXME: Implement support for 'under left' and 'under right' values. |
1685 | 1685 |
1686 ASSERT_NOT_REACHED(); | 1686 NOTREACHED(); |
1687 return TextUnderlinePositionAuto; | 1687 return TextUnderlinePositionAuto; |
1688 } | 1688 } |
1689 | 1689 |
1690 template <> | 1690 template <> |
1691 inline TextDecorationSkip CSSIdentifierValue::convertTo() const { | 1691 inline TextDecorationSkip CSSIdentifierValue::convertTo() const { |
1692 switch (m_valueID) { | 1692 switch (m_valueID) { |
1693 case CSSValueObjects: | 1693 case CSSValueObjects: |
1694 return TextDecorationSkipObjects; | 1694 return TextDecorationSkipObjects; |
1695 case CSSValueInk: | 1695 case CSSValueInk: |
1696 return TextDecorationSkipInk; | 1696 return TextDecorationSkipInk; |
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1729 case CSSValueDisc: | 1729 case CSSValueDisc: |
1730 return TSDISC; | 1730 return TSDISC; |
1731 case CSSValueCircle: | 1731 case CSSValueCircle: |
1732 return TSCIRCLE; | 1732 return TSCIRCLE; |
1733 case CSSValueSquare: | 1733 case CSSValueSquare: |
1734 return TSSQUARE; | 1734 return TSSQUARE; |
1735 default: | 1735 default: |
1736 break; | 1736 break; |
1737 } | 1737 } |
1738 | 1738 |
1739 ASSERT_NOT_REACHED(); | 1739 NOTREACHED(); |
1740 return TSNONE; | 1740 return TSNONE; |
1741 } | 1741 } |
1742 | 1742 |
1743 template <> | 1743 template <> |
1744 inline CSSIdentifierValue::CSSIdentifierValue(EUserDrag e) | 1744 inline CSSIdentifierValue::CSSIdentifierValue(EUserDrag e) |
1745 : CSSValue(IdentifierClass) { | 1745 : CSSValue(IdentifierClass) { |
1746 switch (e) { | 1746 switch (e) { |
1747 case DRAG_AUTO: | 1747 case DRAG_AUTO: |
1748 m_valueID = CSSValueAuto; | 1748 m_valueID = CSSValueAuto; |
1749 break; | 1749 break; |
(...skipping 14 matching lines...) Expand all Loading... |
1764 case CSSValueAuto: | 1764 case CSSValueAuto: |
1765 return DRAG_AUTO; | 1765 return DRAG_AUTO; |
1766 case CSSValueNone: | 1766 case CSSValueNone: |
1767 return DRAG_NONE; | 1767 return DRAG_NONE; |
1768 case CSSValueElement: | 1768 case CSSValueElement: |
1769 return DRAG_ELEMENT; | 1769 return DRAG_ELEMENT; |
1770 default: | 1770 default: |
1771 break; | 1771 break; |
1772 } | 1772 } |
1773 | 1773 |
1774 ASSERT_NOT_REACHED(); | 1774 NOTREACHED(); |
1775 return DRAG_AUTO; | 1775 return DRAG_AUTO; |
1776 } | 1776 } |
1777 | 1777 |
1778 template <> | 1778 template <> |
1779 inline CSSIdentifierValue::CSSIdentifierValue(EUserModify e) | 1779 inline CSSIdentifierValue::CSSIdentifierValue(EUserModify e) |
1780 : CSSValue(IdentifierClass) { | 1780 : CSSValue(IdentifierClass) { |
1781 switch (e) { | 1781 switch (e) { |
1782 case READ_ONLY: | 1782 case READ_ONLY: |
1783 m_valueID = CSSValueReadOnly; | 1783 m_valueID = CSSValueReadOnly; |
1784 break; | 1784 break; |
(...skipping 12 matching lines...) Expand all Loading... |
1797 case CSSValueReadOnly: | 1797 case CSSValueReadOnly: |
1798 return READ_ONLY; | 1798 return READ_ONLY; |
1799 case CSSValueReadWrite: | 1799 case CSSValueReadWrite: |
1800 return READ_WRITE; | 1800 return READ_WRITE; |
1801 case CSSValueReadWritePlaintextOnly: | 1801 case CSSValueReadWritePlaintextOnly: |
1802 return READ_WRITE_PLAINTEXT_ONLY; | 1802 return READ_WRITE_PLAINTEXT_ONLY; |
1803 default: | 1803 default: |
1804 break; | 1804 break; |
1805 } | 1805 } |
1806 | 1806 |
1807 ASSERT_NOT_REACHED(); | 1807 NOTREACHED(); |
1808 return READ_ONLY; | 1808 return READ_ONLY; |
1809 } | 1809 } |
1810 | 1810 |
1811 template <> | 1811 template <> |
1812 inline CSSIdentifierValue::CSSIdentifierValue(EUserSelect e) | 1812 inline CSSIdentifierValue::CSSIdentifierValue(EUserSelect e) |
1813 : CSSValue(IdentifierClass) { | 1813 : CSSValue(IdentifierClass) { |
1814 switch (e) { | 1814 switch (e) { |
1815 case SELECT_NONE: | 1815 case SELECT_NONE: |
1816 m_valueID = CSSValueNone; | 1816 m_valueID = CSSValueNone; |
1817 break; | 1817 break; |
(...skipping 14 matching lines...) Expand all Loading... |
1832 case CSSValueNone: | 1832 case CSSValueNone: |
1833 return SELECT_NONE; | 1833 return SELECT_NONE; |
1834 case CSSValueText: | 1834 case CSSValueText: |
1835 return SELECT_TEXT; | 1835 return SELECT_TEXT; |
1836 case CSSValueAll: | 1836 case CSSValueAll: |
1837 return SELECT_ALL; | 1837 return SELECT_ALL; |
1838 default: | 1838 default: |
1839 break; | 1839 break; |
1840 } | 1840 } |
1841 | 1841 |
1842 ASSERT_NOT_REACHED(); | 1842 NOTREACHED(); |
1843 return SELECT_TEXT; | 1843 return SELECT_TEXT; |
1844 } | 1844 } |
1845 | 1845 |
1846 template <> | 1846 template <> |
1847 inline CSSIdentifierValue::CSSIdentifierValue(EVerticalAlign a) | 1847 inline CSSIdentifierValue::CSSIdentifierValue(EVerticalAlign a) |
1848 : CSSValue(IdentifierClass) { | 1848 : CSSValue(IdentifierClass) { |
1849 switch (a) { | 1849 switch (a) { |
1850 case EVerticalAlign::kTop: | 1850 case EVerticalAlign::kTop: |
1851 m_valueID = CSSValueTop; | 1851 m_valueID = CSSValueTop; |
1852 break; | 1852 break; |
(...skipping 44 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1897 case CSSValueSub: | 1897 case CSSValueSub: |
1898 return EVerticalAlign::kSub; | 1898 return EVerticalAlign::kSub; |
1899 case CSSValueSuper: | 1899 case CSSValueSuper: |
1900 return EVerticalAlign::kSuper; | 1900 return EVerticalAlign::kSuper; |
1901 case CSSValueWebkitBaselineMiddle: | 1901 case CSSValueWebkitBaselineMiddle: |
1902 return EVerticalAlign::kBaselineMiddle; | 1902 return EVerticalAlign::kBaselineMiddle; |
1903 default: | 1903 default: |
1904 break; | 1904 break; |
1905 } | 1905 } |
1906 | 1906 |
1907 ASSERT_NOT_REACHED(); | 1907 NOTREACHED(); |
1908 return EVerticalAlign::kTop; | 1908 return EVerticalAlign::kTop; |
1909 } | 1909 } |
1910 | 1910 |
1911 template <> | 1911 template <> |
1912 inline CSSIdentifierValue::CSSIdentifierValue(EWordBreak e) | 1912 inline CSSIdentifierValue::CSSIdentifierValue(EWordBreak e) |
1913 : CSSValue(IdentifierClass) { | 1913 : CSSValue(IdentifierClass) { |
1914 switch (e) { | 1914 switch (e) { |
1915 case NormalWordBreak: | 1915 case NormalWordBreak: |
1916 m_valueID = CSSValueNormal; | 1916 m_valueID = CSSValueNormal; |
1917 break; | 1917 break; |
(...skipping 17 matching lines...) Expand all Loading... |
1935 case CSSValueBreakWord: | 1935 case CSSValueBreakWord: |
1936 return BreakWordBreak; | 1936 return BreakWordBreak; |
1937 case CSSValueNormal: | 1937 case CSSValueNormal: |
1938 return NormalWordBreak; | 1938 return NormalWordBreak; |
1939 case CSSValueKeepAll: | 1939 case CSSValueKeepAll: |
1940 return KeepAllWordBreak; | 1940 return KeepAllWordBreak; |
1941 default: | 1941 default: |
1942 break; | 1942 break; |
1943 } | 1943 } |
1944 | 1944 |
1945 ASSERT_NOT_REACHED(); | 1945 NOTREACHED(); |
1946 return NormalWordBreak; | 1946 return NormalWordBreak; |
1947 } | 1947 } |
1948 | 1948 |
1949 template <> | 1949 template <> |
1950 inline CSSIdentifierValue::CSSIdentifierValue(EOverflowWrap e) | 1950 inline CSSIdentifierValue::CSSIdentifierValue(EOverflowWrap e) |
1951 : CSSValue(IdentifierClass) { | 1951 : CSSValue(IdentifierClass) { |
1952 switch (e) { | 1952 switch (e) { |
1953 case NormalOverflowWrap: | 1953 case NormalOverflowWrap: |
1954 m_valueID = CSSValueNormal; | 1954 m_valueID = CSSValueNormal; |
1955 break; | 1955 break; |
1956 case BreakOverflowWrap: | 1956 case BreakOverflowWrap: |
1957 m_valueID = CSSValueBreakWord; | 1957 m_valueID = CSSValueBreakWord; |
1958 break; | 1958 break; |
1959 } | 1959 } |
1960 } | 1960 } |
1961 | 1961 |
1962 template <> | 1962 template <> |
1963 inline EOverflowWrap CSSIdentifierValue::convertTo() const { | 1963 inline EOverflowWrap CSSIdentifierValue::convertTo() const { |
1964 switch (m_valueID) { | 1964 switch (m_valueID) { |
1965 case CSSValueBreakWord: | 1965 case CSSValueBreakWord: |
1966 return BreakOverflowWrap; | 1966 return BreakOverflowWrap; |
1967 case CSSValueNormal: | 1967 case CSSValueNormal: |
1968 return NormalOverflowWrap; | 1968 return NormalOverflowWrap; |
1969 default: | 1969 default: |
1970 break; | 1970 break; |
1971 } | 1971 } |
1972 | 1972 |
1973 ASSERT_NOT_REACHED(); | 1973 NOTREACHED(); |
1974 return NormalOverflowWrap; | 1974 return NormalOverflowWrap; |
1975 } | 1975 } |
1976 | 1976 |
1977 template <> | 1977 template <> |
1978 inline CSSIdentifierValue::CSSIdentifierValue(TextCombine e) | 1978 inline CSSIdentifierValue::CSSIdentifierValue(TextCombine e) |
1979 : CSSValue(IdentifierClass) { | 1979 : CSSValue(IdentifierClass) { |
1980 switch (e) { | 1980 switch (e) { |
1981 case TextCombineNone: | 1981 case TextCombineNone: |
1982 m_valueID = CSSValueNone; | 1982 m_valueID = CSSValueNone; |
1983 break; | 1983 break; |
1984 case TextCombineAll: | 1984 case TextCombineAll: |
1985 m_valueID = CSSValueAll; | 1985 m_valueID = CSSValueAll; |
1986 break; | 1986 break; |
1987 } | 1987 } |
1988 } | 1988 } |
1989 | 1989 |
1990 template <> | 1990 template <> |
1991 inline TextCombine CSSIdentifierValue::convertTo() const { | 1991 inline TextCombine CSSIdentifierValue::convertTo() const { |
1992 switch (m_valueID) { | 1992 switch (m_valueID) { |
1993 case CSSValueNone: | 1993 case CSSValueNone: |
1994 return TextCombineNone; | 1994 return TextCombineNone; |
1995 case CSSValueAll: | 1995 case CSSValueAll: |
1996 case CSSValueHorizontal: // -webkit-text-combine | 1996 case CSSValueHorizontal: // -webkit-text-combine |
1997 return TextCombineAll; | 1997 return TextCombineAll; |
1998 default: | 1998 default: |
1999 break; | 1999 break; |
2000 } | 2000 } |
2001 | 2001 |
2002 ASSERT_NOT_REACHED(); | 2002 NOTREACHED(); |
2003 return TextCombineNone; | 2003 return TextCombineNone; |
2004 } | 2004 } |
2005 | 2005 |
2006 template <> | 2006 template <> |
2007 inline CSSIdentifierValue::CSSIdentifierValue(RubyPosition position) | 2007 inline CSSIdentifierValue::CSSIdentifierValue(RubyPosition position) |
2008 : CSSValue(IdentifierClass) { | 2008 : CSSValue(IdentifierClass) { |
2009 switch (position) { | 2009 switch (position) { |
2010 case RubyPositionBefore: | 2010 case RubyPositionBefore: |
2011 m_valueID = CSSValueBefore; | 2011 m_valueID = CSSValueBefore; |
2012 break; | 2012 break; |
2013 case RubyPositionAfter: | 2013 case RubyPositionAfter: |
2014 m_valueID = CSSValueAfter; | 2014 m_valueID = CSSValueAfter; |
2015 break; | 2015 break; |
2016 } | 2016 } |
2017 } | 2017 } |
2018 | 2018 |
2019 template <> | 2019 template <> |
2020 inline RubyPosition CSSIdentifierValue::convertTo() const { | 2020 inline RubyPosition CSSIdentifierValue::convertTo() const { |
2021 switch (m_valueID) { | 2021 switch (m_valueID) { |
2022 case CSSValueBefore: | 2022 case CSSValueBefore: |
2023 return RubyPositionBefore; | 2023 return RubyPositionBefore; |
2024 case CSSValueAfter: | 2024 case CSSValueAfter: |
2025 return RubyPositionAfter; | 2025 return RubyPositionAfter; |
2026 default: | 2026 default: |
2027 break; | 2027 break; |
2028 } | 2028 } |
2029 | 2029 |
2030 ASSERT_NOT_REACHED(); | 2030 NOTREACHED(); |
2031 return RubyPositionBefore; | 2031 return RubyPositionBefore; |
2032 } | 2032 } |
2033 | 2033 |
2034 template <> | 2034 template <> |
2035 inline CSSIdentifierValue::CSSIdentifierValue(TextEmphasisPosition position) | 2035 inline CSSIdentifierValue::CSSIdentifierValue(TextEmphasisPosition position) |
2036 : CSSValue(IdentifierClass) { | 2036 : CSSValue(IdentifierClass) { |
2037 switch (position) { | 2037 switch (position) { |
2038 case TextEmphasisPositionOver: | 2038 case TextEmphasisPositionOver: |
2039 m_valueID = CSSValueOver; | 2039 m_valueID = CSSValueOver; |
2040 break; | 2040 break; |
2041 case TextEmphasisPositionUnder: | 2041 case TextEmphasisPositionUnder: |
2042 m_valueID = CSSValueUnder; | 2042 m_valueID = CSSValueUnder; |
2043 break; | 2043 break; |
2044 } | 2044 } |
2045 } | 2045 } |
2046 | 2046 |
2047 template <> | 2047 template <> |
2048 inline TextEmphasisPosition CSSIdentifierValue::convertTo() const { | 2048 inline TextEmphasisPosition CSSIdentifierValue::convertTo() const { |
2049 switch (m_valueID) { | 2049 switch (m_valueID) { |
2050 case CSSValueOver: | 2050 case CSSValueOver: |
2051 return TextEmphasisPositionOver; | 2051 return TextEmphasisPositionOver; |
2052 case CSSValueUnder: | 2052 case CSSValueUnder: |
2053 return TextEmphasisPositionUnder; | 2053 return TextEmphasisPositionUnder; |
2054 default: | 2054 default: |
2055 break; | 2055 break; |
2056 } | 2056 } |
2057 | 2057 |
2058 ASSERT_NOT_REACHED(); | 2058 NOTREACHED(); |
2059 return TextEmphasisPositionOver; | 2059 return TextEmphasisPositionOver; |
2060 } | 2060 } |
2061 | 2061 |
2062 template <> | 2062 template <> |
2063 inline CSSIdentifierValue::CSSIdentifierValue(TextOverflow overflow) | 2063 inline CSSIdentifierValue::CSSIdentifierValue(TextOverflow overflow) |
2064 : CSSValue(IdentifierClass) { | 2064 : CSSValue(IdentifierClass) { |
2065 switch (overflow) { | 2065 switch (overflow) { |
2066 case TextOverflowClip: | 2066 case TextOverflowClip: |
2067 m_valueID = CSSValueClip; | 2067 m_valueID = CSSValueClip; |
2068 break; | 2068 break; |
2069 case TextOverflowEllipsis: | 2069 case TextOverflowEllipsis: |
2070 m_valueID = CSSValueEllipsis; | 2070 m_valueID = CSSValueEllipsis; |
2071 break; | 2071 break; |
2072 } | 2072 } |
2073 } | 2073 } |
2074 | 2074 |
2075 template <> | 2075 template <> |
2076 inline TextOverflow CSSIdentifierValue::convertTo() const { | 2076 inline TextOverflow CSSIdentifierValue::convertTo() const { |
2077 switch (m_valueID) { | 2077 switch (m_valueID) { |
2078 case CSSValueClip: | 2078 case CSSValueClip: |
2079 return TextOverflowClip; | 2079 return TextOverflowClip; |
2080 case CSSValueEllipsis: | 2080 case CSSValueEllipsis: |
2081 return TextOverflowEllipsis; | 2081 return TextOverflowEllipsis; |
2082 default: | 2082 default: |
2083 break; | 2083 break; |
2084 } | 2084 } |
2085 | 2085 |
2086 ASSERT_NOT_REACHED(); | 2086 NOTREACHED(); |
2087 return TextOverflowClip; | 2087 return TextOverflowClip; |
2088 } | 2088 } |
2089 | 2089 |
2090 template <> | 2090 template <> |
2091 inline CSSIdentifierValue::CSSIdentifierValue(TextEmphasisFill fill) | 2091 inline CSSIdentifierValue::CSSIdentifierValue(TextEmphasisFill fill) |
2092 : CSSValue(IdentifierClass) { | 2092 : CSSValue(IdentifierClass) { |
2093 switch (fill) { | 2093 switch (fill) { |
2094 case TextEmphasisFillFilled: | 2094 case TextEmphasisFillFilled: |
2095 m_valueID = CSSValueFilled; | 2095 m_valueID = CSSValueFilled; |
2096 break; | 2096 break; |
2097 case TextEmphasisFillOpen: | 2097 case TextEmphasisFillOpen: |
2098 m_valueID = CSSValueOpen; | 2098 m_valueID = CSSValueOpen; |
2099 break; | 2099 break; |
2100 } | 2100 } |
2101 } | 2101 } |
2102 | 2102 |
2103 template <> | 2103 template <> |
2104 inline TextEmphasisFill CSSIdentifierValue::convertTo() const { | 2104 inline TextEmphasisFill CSSIdentifierValue::convertTo() const { |
2105 switch (m_valueID) { | 2105 switch (m_valueID) { |
2106 case CSSValueFilled: | 2106 case CSSValueFilled: |
2107 return TextEmphasisFillFilled; | 2107 return TextEmphasisFillFilled; |
2108 case CSSValueOpen: | 2108 case CSSValueOpen: |
2109 return TextEmphasisFillOpen; | 2109 return TextEmphasisFillOpen; |
2110 default: | 2110 default: |
2111 break; | 2111 break; |
2112 } | 2112 } |
2113 | 2113 |
2114 ASSERT_NOT_REACHED(); | 2114 NOTREACHED(); |
2115 return TextEmphasisFillFilled; | 2115 return TextEmphasisFillFilled; |
2116 } | 2116 } |
2117 | 2117 |
2118 template <> | 2118 template <> |
2119 inline CSSIdentifierValue::CSSIdentifierValue(TextEmphasisMark mark) | 2119 inline CSSIdentifierValue::CSSIdentifierValue(TextEmphasisMark mark) |
2120 : CSSValue(IdentifierClass) { | 2120 : CSSValue(IdentifierClass) { |
2121 switch (mark) { | 2121 switch (mark) { |
2122 case TextEmphasisMarkDot: | 2122 case TextEmphasisMarkDot: |
2123 m_valueID = CSSValueDot; | 2123 m_valueID = CSSValueDot; |
2124 break; | 2124 break; |
2125 case TextEmphasisMarkCircle: | 2125 case TextEmphasisMarkCircle: |
2126 m_valueID = CSSValueCircle; | 2126 m_valueID = CSSValueCircle; |
2127 break; | 2127 break; |
2128 case TextEmphasisMarkDoubleCircle: | 2128 case TextEmphasisMarkDoubleCircle: |
2129 m_valueID = CSSValueDoubleCircle; | 2129 m_valueID = CSSValueDoubleCircle; |
2130 break; | 2130 break; |
2131 case TextEmphasisMarkTriangle: | 2131 case TextEmphasisMarkTriangle: |
2132 m_valueID = CSSValueTriangle; | 2132 m_valueID = CSSValueTriangle; |
2133 break; | 2133 break; |
2134 case TextEmphasisMarkSesame: | 2134 case TextEmphasisMarkSesame: |
2135 m_valueID = CSSValueSesame; | 2135 m_valueID = CSSValueSesame; |
2136 break; | 2136 break; |
2137 case TextEmphasisMarkNone: | 2137 case TextEmphasisMarkNone: |
2138 case TextEmphasisMarkAuto: | 2138 case TextEmphasisMarkAuto: |
2139 case TextEmphasisMarkCustom: | 2139 case TextEmphasisMarkCustom: |
2140 ASSERT_NOT_REACHED(); | 2140 NOTREACHED(); |
2141 m_valueID = CSSValueNone; | 2141 m_valueID = CSSValueNone; |
2142 break; | 2142 break; |
2143 } | 2143 } |
2144 } | 2144 } |
2145 | 2145 |
2146 template <> | 2146 template <> |
2147 inline TextEmphasisMark CSSIdentifierValue::convertTo() const { | 2147 inline TextEmphasisMark CSSIdentifierValue::convertTo() const { |
2148 switch (m_valueID) { | 2148 switch (m_valueID) { |
2149 case CSSValueNone: | 2149 case CSSValueNone: |
2150 return TextEmphasisMarkNone; | 2150 return TextEmphasisMarkNone; |
2151 case CSSValueDot: | 2151 case CSSValueDot: |
2152 return TextEmphasisMarkDot; | 2152 return TextEmphasisMarkDot; |
2153 case CSSValueCircle: | 2153 case CSSValueCircle: |
2154 return TextEmphasisMarkCircle; | 2154 return TextEmphasisMarkCircle; |
2155 case CSSValueDoubleCircle: | 2155 case CSSValueDoubleCircle: |
2156 return TextEmphasisMarkDoubleCircle; | 2156 return TextEmphasisMarkDoubleCircle; |
2157 case CSSValueTriangle: | 2157 case CSSValueTriangle: |
2158 return TextEmphasisMarkTriangle; | 2158 return TextEmphasisMarkTriangle; |
2159 case CSSValueSesame: | 2159 case CSSValueSesame: |
2160 return TextEmphasisMarkSesame; | 2160 return TextEmphasisMarkSesame; |
2161 default: | 2161 default: |
2162 break; | 2162 break; |
2163 } | 2163 } |
2164 | 2164 |
2165 ASSERT_NOT_REACHED(); | 2165 NOTREACHED(); |
2166 return TextEmphasisMarkNone; | 2166 return TextEmphasisMarkNone; |
2167 } | 2167 } |
2168 | 2168 |
2169 template <> | 2169 template <> |
2170 inline CSSIdentifierValue::CSSIdentifierValue(TextOrientation e) | 2170 inline CSSIdentifierValue::CSSIdentifierValue(TextOrientation e) |
2171 : CSSValue(IdentifierClass) { | 2171 : CSSValue(IdentifierClass) { |
2172 switch (e) { | 2172 switch (e) { |
2173 case TextOrientationSideways: | 2173 case TextOrientationSideways: |
2174 m_valueID = CSSValueSideways; | 2174 m_valueID = CSSValueSideways; |
2175 break; | 2175 break; |
(...skipping 14 matching lines...) Expand all Loading... |
2190 return TextOrientationSideways; | 2190 return TextOrientationSideways; |
2191 case CSSValueMixed: | 2191 case CSSValueMixed: |
2192 case CSSValueVerticalRight: // -webkit-text-orientation | 2192 case CSSValueVerticalRight: // -webkit-text-orientation |
2193 return TextOrientationMixed; | 2193 return TextOrientationMixed; |
2194 case CSSValueUpright: | 2194 case CSSValueUpright: |
2195 return TextOrientationUpright; | 2195 return TextOrientationUpright; |
2196 default: | 2196 default: |
2197 break; | 2197 break; |
2198 } | 2198 } |
2199 | 2199 |
2200 ASSERT_NOT_REACHED(); | 2200 NOTREACHED(); |
2201 return TextOrientationMixed; | 2201 return TextOrientationMixed; |
2202 } | 2202 } |
2203 | 2203 |
2204 template <> | 2204 template <> |
2205 inline CSSIdentifierValue::CSSIdentifierValue(FontDescription::Kerning kerning) | 2205 inline CSSIdentifierValue::CSSIdentifierValue(FontDescription::Kerning kerning) |
2206 : CSSValue(IdentifierClass) { | 2206 : CSSValue(IdentifierClass) { |
2207 switch (kerning) { | 2207 switch (kerning) { |
2208 case FontDescription::AutoKerning: | 2208 case FontDescription::AutoKerning: |
2209 m_valueID = CSSValueAuto; | 2209 m_valueID = CSSValueAuto; |
2210 return; | 2210 return; |
2211 case FontDescription::NormalKerning: | 2211 case FontDescription::NormalKerning: |
2212 m_valueID = CSSValueNormal; | 2212 m_valueID = CSSValueNormal; |
2213 return; | 2213 return; |
2214 case FontDescription::NoneKerning: | 2214 case FontDescription::NoneKerning: |
2215 m_valueID = CSSValueNone; | 2215 m_valueID = CSSValueNone; |
2216 return; | 2216 return; |
2217 } | 2217 } |
2218 | 2218 |
2219 ASSERT_NOT_REACHED(); | 2219 NOTREACHED(); |
2220 m_valueID = CSSValueAuto; | 2220 m_valueID = CSSValueAuto; |
2221 } | 2221 } |
2222 | 2222 |
2223 template <> | 2223 template <> |
2224 inline FontDescription::Kerning CSSIdentifierValue::convertTo() const { | 2224 inline FontDescription::Kerning CSSIdentifierValue::convertTo() const { |
2225 switch (m_valueID) { | 2225 switch (m_valueID) { |
2226 case CSSValueAuto: | 2226 case CSSValueAuto: |
2227 return FontDescription::AutoKerning; | 2227 return FontDescription::AutoKerning; |
2228 case CSSValueNormal: | 2228 case CSSValueNormal: |
2229 return FontDescription::NormalKerning; | 2229 return FontDescription::NormalKerning; |
2230 case CSSValueNone: | 2230 case CSSValueNone: |
2231 return FontDescription::NoneKerning; | 2231 return FontDescription::NoneKerning; |
2232 default: | 2232 default: |
2233 break; | 2233 break; |
2234 } | 2234 } |
2235 | 2235 |
2236 ASSERT_NOT_REACHED(); | 2236 NOTREACHED(); |
2237 return FontDescription::AutoKerning; | 2237 return FontDescription::AutoKerning; |
2238 } | 2238 } |
2239 | 2239 |
2240 template <> | 2240 template <> |
2241 inline CSSIdentifierValue::CSSIdentifierValue(ObjectFit fit) | 2241 inline CSSIdentifierValue::CSSIdentifierValue(ObjectFit fit) |
2242 : CSSValue(IdentifierClass) { | 2242 : CSSValue(IdentifierClass) { |
2243 switch (fit) { | 2243 switch (fit) { |
2244 case ObjectFitFill: | 2244 case ObjectFitFill: |
2245 m_valueID = CSSValueFill; | 2245 m_valueID = CSSValueFill; |
2246 break; | 2246 break; |
(...skipping 19 matching lines...) Expand all Loading... |
2266 return ObjectFitFill; | 2266 return ObjectFitFill; |
2267 case CSSValueContain: | 2267 case CSSValueContain: |
2268 return ObjectFitContain; | 2268 return ObjectFitContain; |
2269 case CSSValueCover: | 2269 case CSSValueCover: |
2270 return ObjectFitCover; | 2270 return ObjectFitCover; |
2271 case CSSValueNone: | 2271 case CSSValueNone: |
2272 return ObjectFitNone; | 2272 return ObjectFitNone; |
2273 case CSSValueScaleDown: | 2273 case CSSValueScaleDown: |
2274 return ObjectFitScaleDown; | 2274 return ObjectFitScaleDown; |
2275 default: | 2275 default: |
2276 ASSERT_NOT_REACHED(); | 2276 NOTREACHED(); |
2277 return ObjectFitFill; | 2277 return ObjectFitFill; |
2278 } | 2278 } |
2279 } | 2279 } |
2280 | 2280 |
2281 template <> | 2281 template <> |
2282 inline CSSIdentifierValue::CSSIdentifierValue(EFillSizeType fillSize) | 2282 inline CSSIdentifierValue::CSSIdentifierValue(EFillSizeType fillSize) |
2283 : CSSValue(IdentifierClass) { | 2283 : CSSValue(IdentifierClass) { |
2284 switch (fillSize) { | 2284 switch (fillSize) { |
2285 case Contain: | 2285 case Contain: |
2286 m_valueID = CSSValueContain; | 2286 m_valueID = CSSValueContain; |
2287 break; | 2287 break; |
2288 case Cover: | 2288 case Cover: |
2289 m_valueID = CSSValueCover; | 2289 m_valueID = CSSValueCover; |
2290 break; | 2290 break; |
2291 case SizeNone: | 2291 case SizeNone: |
2292 m_valueID = CSSValueNone; | 2292 m_valueID = CSSValueNone; |
2293 break; | 2293 break; |
2294 case SizeLength: | 2294 case SizeLength: |
2295 default: | 2295 default: |
2296 ASSERT_NOT_REACHED(); | 2296 NOTREACHED(); |
2297 } | 2297 } |
2298 } | 2298 } |
2299 | 2299 |
2300 template <> | 2300 template <> |
2301 inline CSSIdentifierValue::CSSIdentifierValue(FontSmoothingMode smoothing) | 2301 inline CSSIdentifierValue::CSSIdentifierValue(FontSmoothingMode smoothing) |
2302 : CSSValue(IdentifierClass) { | 2302 : CSSValue(IdentifierClass) { |
2303 switch (smoothing) { | 2303 switch (smoothing) { |
2304 case AutoSmoothing: | 2304 case AutoSmoothing: |
2305 m_valueID = CSSValueAuto; | 2305 m_valueID = CSSValueAuto; |
2306 return; | 2306 return; |
2307 case NoSmoothing: | 2307 case NoSmoothing: |
2308 m_valueID = CSSValueNone; | 2308 m_valueID = CSSValueNone; |
2309 return; | 2309 return; |
2310 case Antialiased: | 2310 case Antialiased: |
2311 m_valueID = CSSValueAntialiased; | 2311 m_valueID = CSSValueAntialiased; |
2312 return; | 2312 return; |
2313 case SubpixelAntialiased: | 2313 case SubpixelAntialiased: |
2314 m_valueID = CSSValueSubpixelAntialiased; | 2314 m_valueID = CSSValueSubpixelAntialiased; |
2315 return; | 2315 return; |
2316 } | 2316 } |
2317 | 2317 |
2318 ASSERT_NOT_REACHED(); | 2318 NOTREACHED(); |
2319 m_valueID = CSSValueAuto; | 2319 m_valueID = CSSValueAuto; |
2320 } | 2320 } |
2321 | 2321 |
2322 template <> | 2322 template <> |
2323 inline FontSmoothingMode CSSIdentifierValue::convertTo() const { | 2323 inline FontSmoothingMode CSSIdentifierValue::convertTo() const { |
2324 switch (m_valueID) { | 2324 switch (m_valueID) { |
2325 case CSSValueAuto: | 2325 case CSSValueAuto: |
2326 return AutoSmoothing; | 2326 return AutoSmoothing; |
2327 case CSSValueNone: | 2327 case CSSValueNone: |
2328 return NoSmoothing; | 2328 return NoSmoothing; |
2329 case CSSValueAntialiased: | 2329 case CSSValueAntialiased: |
2330 return Antialiased; | 2330 return Antialiased; |
2331 case CSSValueSubpixelAntialiased: | 2331 case CSSValueSubpixelAntialiased: |
2332 return SubpixelAntialiased; | 2332 return SubpixelAntialiased; |
2333 default: | 2333 default: |
2334 break; | 2334 break; |
2335 } | 2335 } |
2336 | 2336 |
2337 ASSERT_NOT_REACHED(); | 2337 NOTREACHED(); |
2338 return AutoSmoothing; | 2338 return AutoSmoothing; |
2339 } | 2339 } |
2340 | 2340 |
2341 template <> | 2341 template <> |
2342 inline CSSIdentifierValue::CSSIdentifierValue(FontWeight weight) | 2342 inline CSSIdentifierValue::CSSIdentifierValue(FontWeight weight) |
2343 : CSSValue(IdentifierClass) { | 2343 : CSSValue(IdentifierClass) { |
2344 switch (weight) { | 2344 switch (weight) { |
2345 case FontWeight900: | 2345 case FontWeight900: |
2346 m_valueID = CSSValue900; | 2346 m_valueID = CSSValue900; |
2347 return; | 2347 return; |
(...skipping 16 matching lines...) Expand all Loading... |
2364 m_valueID = CSSValue300; | 2364 m_valueID = CSSValue300; |
2365 return; | 2365 return; |
2366 case FontWeight200: | 2366 case FontWeight200: |
2367 m_valueID = CSSValue200; | 2367 m_valueID = CSSValue200; |
2368 return; | 2368 return; |
2369 case FontWeight100: | 2369 case FontWeight100: |
2370 m_valueID = CSSValue100; | 2370 m_valueID = CSSValue100; |
2371 return; | 2371 return; |
2372 } | 2372 } |
2373 | 2373 |
2374 ASSERT_NOT_REACHED(); | 2374 NOTREACHED(); |
2375 m_valueID = CSSValueNormal; | 2375 m_valueID = CSSValueNormal; |
2376 } | 2376 } |
2377 | 2377 |
2378 template <> | 2378 template <> |
2379 inline FontWeight CSSIdentifierValue::convertTo() const { | 2379 inline FontWeight CSSIdentifierValue::convertTo() const { |
2380 switch (m_valueID) { | 2380 switch (m_valueID) { |
2381 case CSSValueBold: | 2381 case CSSValueBold: |
2382 return FontWeightBold; | 2382 return FontWeightBold; |
2383 case CSSValueNormal: | 2383 case CSSValueNormal: |
2384 return FontWeightNormal; | 2384 return FontWeightNormal; |
(...skipping 12 matching lines...) Expand all Loading... |
2397 case CSSValue300: | 2397 case CSSValue300: |
2398 return FontWeight300; | 2398 return FontWeight300; |
2399 case CSSValue200: | 2399 case CSSValue200: |
2400 return FontWeight200; | 2400 return FontWeight200; |
2401 case CSSValue100: | 2401 case CSSValue100: |
2402 return FontWeight100; | 2402 return FontWeight100; |
2403 default: | 2403 default: |
2404 break; | 2404 break; |
2405 } | 2405 } |
2406 | 2406 |
2407 ASSERT_NOT_REACHED(); | 2407 NOTREACHED(); |
2408 return FontWeightNormal; | 2408 return FontWeightNormal; |
2409 } | 2409 } |
2410 | 2410 |
2411 template <> | 2411 template <> |
2412 inline CSSIdentifierValue::CSSIdentifierValue(FontStyle italic) | 2412 inline CSSIdentifierValue::CSSIdentifierValue(FontStyle italic) |
2413 : CSSValue(IdentifierClass) { | 2413 : CSSValue(IdentifierClass) { |
2414 switch (italic) { | 2414 switch (italic) { |
2415 case FontStyleNormal: | 2415 case FontStyleNormal: |
2416 m_valueID = CSSValueNormal; | 2416 m_valueID = CSSValueNormal; |
2417 return; | 2417 return; |
2418 case FontStyleOblique: | 2418 case FontStyleOblique: |
2419 m_valueID = CSSValueOblique; | 2419 m_valueID = CSSValueOblique; |
2420 return; | 2420 return; |
2421 case FontStyleItalic: | 2421 case FontStyleItalic: |
2422 m_valueID = CSSValueItalic; | 2422 m_valueID = CSSValueItalic; |
2423 return; | 2423 return; |
2424 } | 2424 } |
2425 | 2425 |
2426 ASSERT_NOT_REACHED(); | 2426 NOTREACHED(); |
2427 m_valueID = CSSValueNormal; | 2427 m_valueID = CSSValueNormal; |
2428 } | 2428 } |
2429 | 2429 |
2430 template <> | 2430 template <> |
2431 inline FontStyle CSSIdentifierValue::convertTo() const { | 2431 inline FontStyle CSSIdentifierValue::convertTo() const { |
2432 switch (m_valueID) { | 2432 switch (m_valueID) { |
2433 case CSSValueOblique: | 2433 case CSSValueOblique: |
2434 return FontStyleOblique; | 2434 return FontStyleOblique; |
2435 case CSSValueItalic: | 2435 case CSSValueItalic: |
2436 return FontStyleItalic; | 2436 return FontStyleItalic; |
2437 case CSSValueNormal: | 2437 case CSSValueNormal: |
2438 return FontStyleNormal; | 2438 return FontStyleNormal; |
2439 default: | 2439 default: |
2440 break; | 2440 break; |
2441 } | 2441 } |
2442 ASSERT_NOT_REACHED(); | 2442 NOTREACHED(); |
2443 return FontStyleNormal; | 2443 return FontStyleNormal; |
2444 } | 2444 } |
2445 | 2445 |
2446 template <> | 2446 template <> |
2447 inline CSSIdentifierValue::CSSIdentifierValue(FontStretch stretch) | 2447 inline CSSIdentifierValue::CSSIdentifierValue(FontStretch stretch) |
2448 : CSSValue(IdentifierClass) { | 2448 : CSSValue(IdentifierClass) { |
2449 switch (stretch) { | 2449 switch (stretch) { |
2450 case FontStretchUltraCondensed: | 2450 case FontStretchUltraCondensed: |
2451 m_valueID = CSSValueUltraCondensed; | 2451 m_valueID = CSSValueUltraCondensed; |
2452 return; | 2452 return; |
(...skipping 16 matching lines...) Expand all Loading... |
2469 m_valueID = CSSValueExpanded; | 2469 m_valueID = CSSValueExpanded; |
2470 return; | 2470 return; |
2471 case FontStretchExtraExpanded: | 2471 case FontStretchExtraExpanded: |
2472 m_valueID = CSSValueExtraExpanded; | 2472 m_valueID = CSSValueExtraExpanded; |
2473 return; | 2473 return; |
2474 case FontStretchUltraExpanded: | 2474 case FontStretchUltraExpanded: |
2475 m_valueID = CSSValueUltraExpanded; | 2475 m_valueID = CSSValueUltraExpanded; |
2476 return; | 2476 return; |
2477 } | 2477 } |
2478 | 2478 |
2479 ASSERT_NOT_REACHED(); | 2479 NOTREACHED(); |
2480 m_valueID = CSSValueNormal; | 2480 m_valueID = CSSValueNormal; |
2481 } | 2481 } |
2482 | 2482 |
2483 template <> | 2483 template <> |
2484 inline FontStretch CSSIdentifierValue::convertTo() const { | 2484 inline FontStretch CSSIdentifierValue::convertTo() const { |
2485 switch (m_valueID) { | 2485 switch (m_valueID) { |
2486 case CSSValueUltraCondensed: | 2486 case CSSValueUltraCondensed: |
2487 return FontStretchUltraCondensed; | 2487 return FontStretchUltraCondensed; |
2488 case CSSValueExtraCondensed: | 2488 case CSSValueExtraCondensed: |
2489 return FontStretchExtraCondensed; | 2489 return FontStretchExtraCondensed; |
2490 case CSSValueCondensed: | 2490 case CSSValueCondensed: |
2491 return FontStretchCondensed; | 2491 return FontStretchCondensed; |
2492 case CSSValueSemiCondensed: | 2492 case CSSValueSemiCondensed: |
2493 return FontStretchSemiCondensed; | 2493 return FontStretchSemiCondensed; |
2494 case CSSValueNormal: | 2494 case CSSValueNormal: |
2495 return FontStretchNormal; | 2495 return FontStretchNormal; |
2496 case CSSValueSemiExpanded: | 2496 case CSSValueSemiExpanded: |
2497 return FontStretchSemiExpanded; | 2497 return FontStretchSemiExpanded; |
2498 case CSSValueExpanded: | 2498 case CSSValueExpanded: |
2499 return FontStretchExpanded; | 2499 return FontStretchExpanded; |
2500 case CSSValueExtraExpanded: | 2500 case CSSValueExtraExpanded: |
2501 return FontStretchExtraExpanded; | 2501 return FontStretchExtraExpanded; |
2502 case CSSValueUltraExpanded: | 2502 case CSSValueUltraExpanded: |
2503 return FontStretchUltraExpanded; | 2503 return FontStretchUltraExpanded; |
2504 default: | 2504 default: |
2505 break; | 2505 break; |
2506 } | 2506 } |
2507 | 2507 |
2508 ASSERT_NOT_REACHED(); | 2508 NOTREACHED(); |
2509 return FontStretchNormal; | 2509 return FontStretchNormal; |
2510 } | 2510 } |
2511 | 2511 |
2512 template <> | 2512 template <> |
2513 inline CSSIdentifierValue::CSSIdentifierValue(TextRenderingMode e) | 2513 inline CSSIdentifierValue::CSSIdentifierValue(TextRenderingMode e) |
2514 : CSSValue(IdentifierClass) { | 2514 : CSSValue(IdentifierClass) { |
2515 switch (e) { | 2515 switch (e) { |
2516 case AutoTextRendering: | 2516 case AutoTextRendering: |
2517 m_valueID = CSSValueAuto; | 2517 m_valueID = CSSValueAuto; |
2518 break; | 2518 break; |
(...skipping 17 matching lines...) Expand all Loading... |
2536 case CSSValueOptimizeSpeed: | 2536 case CSSValueOptimizeSpeed: |
2537 return OptimizeSpeed; | 2537 return OptimizeSpeed; |
2538 case CSSValueOptimizeLegibility: | 2538 case CSSValueOptimizeLegibility: |
2539 return OptimizeLegibility; | 2539 return OptimizeLegibility; |
2540 case CSSValueGeometricPrecision: | 2540 case CSSValueGeometricPrecision: |
2541 return GeometricPrecision; | 2541 return GeometricPrecision; |
2542 default: | 2542 default: |
2543 break; | 2543 break; |
2544 } | 2544 } |
2545 | 2545 |
2546 ASSERT_NOT_REACHED(); | 2546 NOTREACHED(); |
2547 return AutoTextRendering; | 2547 return AutoTextRendering; |
2548 } | 2548 } |
2549 | 2549 |
2550 template <> | 2550 template <> |
2551 inline CSSIdentifierValue::CSSIdentifierValue(ESpeak e) | 2551 inline CSSIdentifierValue::CSSIdentifierValue(ESpeak e) |
2552 : CSSValue(IdentifierClass) { | 2552 : CSSValue(IdentifierClass) { |
2553 switch (e) { | 2553 switch (e) { |
2554 case SpeakNone: | 2554 case SpeakNone: |
2555 m_valueID = CSSValueNone; | 2555 m_valueID = CSSValueNone; |
2556 break; | 2556 break; |
(...skipping 19 matching lines...) Expand all Loading... |
2576 inline EOrder CSSIdentifierValue::convertTo() const { | 2576 inline EOrder CSSIdentifierValue::convertTo() const { |
2577 switch (m_valueID) { | 2577 switch (m_valueID) { |
2578 case CSSValueLogical: | 2578 case CSSValueLogical: |
2579 return EOrder::kLogical; | 2579 return EOrder::kLogical; |
2580 case CSSValueVisual: | 2580 case CSSValueVisual: |
2581 return EOrder::kVisual; | 2581 return EOrder::kVisual; |
2582 default: | 2582 default: |
2583 break; | 2583 break; |
2584 } | 2584 } |
2585 | 2585 |
2586 ASSERT_NOT_REACHED(); | 2586 NOTREACHED(); |
2587 return EOrder::kLogical; | 2587 return EOrder::kLogical; |
2588 } | 2588 } |
2589 | 2589 |
2590 template <> | 2590 template <> |
2591 inline CSSIdentifierValue::CSSIdentifierValue(EOrder e) | 2591 inline CSSIdentifierValue::CSSIdentifierValue(EOrder e) |
2592 : CSSValue(IdentifierClass) { | 2592 : CSSValue(IdentifierClass) { |
2593 switch (e) { | 2593 switch (e) { |
2594 case EOrder::kLogical: | 2594 case EOrder::kLogical: |
2595 m_valueID = CSSValueLogical; | 2595 m_valueID = CSSValueLogical; |
2596 break; | 2596 break; |
(...skipping 15 matching lines...) Expand all Loading... |
2612 case CSSValueDigits: | 2612 case CSSValueDigits: |
2613 return SpeakDigits; | 2613 return SpeakDigits; |
2614 case CSSValueLiteralPunctuation: | 2614 case CSSValueLiteralPunctuation: |
2615 return SpeakLiteralPunctuation; | 2615 return SpeakLiteralPunctuation; |
2616 case CSSValueNoPunctuation: | 2616 case CSSValueNoPunctuation: |
2617 return SpeakNoPunctuation; | 2617 return SpeakNoPunctuation; |
2618 default: | 2618 default: |
2619 break; | 2619 break; |
2620 } | 2620 } |
2621 | 2621 |
2622 ASSERT_NOT_REACHED(); | 2622 NOTREACHED(); |
2623 return SpeakNormal; | 2623 return SpeakNormal; |
2624 } | 2624 } |
2625 | 2625 |
2626 template <> | 2626 template <> |
2627 inline CSSIdentifierValue::CSSIdentifierValue(WebBlendMode blendMode) | 2627 inline CSSIdentifierValue::CSSIdentifierValue(WebBlendMode blendMode) |
2628 : CSSValue(IdentifierClass) { | 2628 : CSSValue(IdentifierClass) { |
2629 switch (blendMode) { | 2629 switch (blendMode) { |
2630 case WebBlendModeNormal: | 2630 case WebBlendModeNormal: |
2631 m_valueID = CSSValueNormal; | 2631 m_valueID = CSSValueNormal; |
2632 break; | 2632 break; |
(...skipping 77 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2710 case CSSValueSaturation: | 2710 case CSSValueSaturation: |
2711 return WebBlendModeSaturation; | 2711 return WebBlendModeSaturation; |
2712 case CSSValueColor: | 2712 case CSSValueColor: |
2713 return WebBlendModeColor; | 2713 return WebBlendModeColor; |
2714 case CSSValueLuminosity: | 2714 case CSSValueLuminosity: |
2715 return WebBlendModeLuminosity; | 2715 return WebBlendModeLuminosity; |
2716 default: | 2716 default: |
2717 break; | 2717 break; |
2718 } | 2718 } |
2719 | 2719 |
2720 ASSERT_NOT_REACHED(); | 2720 NOTREACHED(); |
2721 return WebBlendModeNormal; | 2721 return WebBlendModeNormal; |
2722 } | 2722 } |
2723 | 2723 |
2724 template <> | 2724 template <> |
2725 inline CSSIdentifierValue::CSSIdentifierValue(LineCap e) | 2725 inline CSSIdentifierValue::CSSIdentifierValue(LineCap e) |
2726 : CSSValue(IdentifierClass) { | 2726 : CSSValue(IdentifierClass) { |
2727 switch (e) { | 2727 switch (e) { |
2728 case ButtCap: | 2728 case ButtCap: |
2729 m_valueID = CSSValueButt; | 2729 m_valueID = CSSValueButt; |
2730 break; | 2730 break; |
(...skipping 12 matching lines...) Expand all Loading... |
2743 case CSSValueButt: | 2743 case CSSValueButt: |
2744 return ButtCap; | 2744 return ButtCap; |
2745 case CSSValueRound: | 2745 case CSSValueRound: |
2746 return RoundCap; | 2746 return RoundCap; |
2747 case CSSValueSquare: | 2747 case CSSValueSquare: |
2748 return SquareCap; | 2748 return SquareCap; |
2749 default: | 2749 default: |
2750 break; | 2750 break; |
2751 } | 2751 } |
2752 | 2752 |
2753 ASSERT_NOT_REACHED(); | 2753 NOTREACHED(); |
2754 return ButtCap; | 2754 return ButtCap; |
2755 } | 2755 } |
2756 | 2756 |
2757 template <> | 2757 template <> |
2758 inline CSSIdentifierValue::CSSIdentifierValue(LineJoin e) | 2758 inline CSSIdentifierValue::CSSIdentifierValue(LineJoin e) |
2759 : CSSValue(IdentifierClass) { | 2759 : CSSValue(IdentifierClass) { |
2760 switch (e) { | 2760 switch (e) { |
2761 case MiterJoin: | 2761 case MiterJoin: |
2762 m_valueID = CSSValueMiter; | 2762 m_valueID = CSSValueMiter; |
2763 break; | 2763 break; |
(...skipping 12 matching lines...) Expand all Loading... |
2776 case CSSValueMiter: | 2776 case CSSValueMiter: |
2777 return MiterJoin; | 2777 return MiterJoin; |
2778 case CSSValueRound: | 2778 case CSSValueRound: |
2779 return RoundJoin; | 2779 return RoundJoin; |
2780 case CSSValueBevel: | 2780 case CSSValueBevel: |
2781 return BevelJoin; | 2781 return BevelJoin; |
2782 default: | 2782 default: |
2783 break; | 2783 break; |
2784 } | 2784 } |
2785 | 2785 |
2786 ASSERT_NOT_REACHED(); | 2786 NOTREACHED(); |
2787 return MiterJoin; | 2787 return MiterJoin; |
2788 } | 2788 } |
2789 | 2789 |
2790 template <> | 2790 template <> |
2791 inline CSSIdentifierValue::CSSIdentifierValue(WindRule e) | 2791 inline CSSIdentifierValue::CSSIdentifierValue(WindRule e) |
2792 : CSSValue(IdentifierClass) { | 2792 : CSSValue(IdentifierClass) { |
2793 switch (e) { | 2793 switch (e) { |
2794 case RULE_NONZERO: | 2794 case RULE_NONZERO: |
2795 m_valueID = CSSValueNonzero; | 2795 m_valueID = CSSValueNonzero; |
2796 break; | 2796 break; |
2797 case RULE_EVENODD: | 2797 case RULE_EVENODD: |
2798 m_valueID = CSSValueEvenodd; | 2798 m_valueID = CSSValueEvenodd; |
2799 break; | 2799 break; |
2800 } | 2800 } |
2801 } | 2801 } |
2802 | 2802 |
2803 template <> | 2803 template <> |
2804 inline WindRule CSSIdentifierValue::convertTo() const { | 2804 inline WindRule CSSIdentifierValue::convertTo() const { |
2805 switch (m_valueID) { | 2805 switch (m_valueID) { |
2806 case CSSValueNonzero: | 2806 case CSSValueNonzero: |
2807 return RULE_NONZERO; | 2807 return RULE_NONZERO; |
2808 case CSSValueEvenodd: | 2808 case CSSValueEvenodd: |
2809 return RULE_EVENODD; | 2809 return RULE_EVENODD; |
2810 default: | 2810 default: |
2811 break; | 2811 break; |
2812 } | 2812 } |
2813 | 2813 |
2814 ASSERT_NOT_REACHED(); | 2814 NOTREACHED(); |
2815 return RULE_NONZERO; | 2815 return RULE_NONZERO; |
2816 } | 2816 } |
2817 | 2817 |
2818 template <> | 2818 template <> |
2819 inline CSSIdentifierValue::CSSIdentifierValue(EAlignmentBaseline e) | 2819 inline CSSIdentifierValue::CSSIdentifierValue(EAlignmentBaseline e) |
2820 : CSSValue(IdentifierClass) { | 2820 : CSSValue(IdentifierClass) { |
2821 switch (e) { | 2821 switch (e) { |
2822 case AB_AUTO: | 2822 case AB_AUTO: |
2823 m_valueID = CSSValueAuto; | 2823 m_valueID = CSSValueAuto; |
2824 break; | 2824 break; |
(...skipping 57 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2882 case CSSValueAlphabetic: | 2882 case CSSValueAlphabetic: |
2883 return AB_ALPHABETIC; | 2883 return AB_ALPHABETIC; |
2884 case CSSValueHanging: | 2884 case CSSValueHanging: |
2885 return AB_HANGING; | 2885 return AB_HANGING; |
2886 case CSSValueMathematical: | 2886 case CSSValueMathematical: |
2887 return AB_MATHEMATICAL; | 2887 return AB_MATHEMATICAL; |
2888 default: | 2888 default: |
2889 break; | 2889 break; |
2890 } | 2890 } |
2891 | 2891 |
2892 ASSERT_NOT_REACHED(); | 2892 NOTREACHED(); |
2893 return AB_AUTO; | 2893 return AB_AUTO; |
2894 } | 2894 } |
2895 | 2895 |
2896 template <> | 2896 template <> |
2897 inline CSSIdentifierValue::CSSIdentifierValue(EImageRendering e) | 2897 inline CSSIdentifierValue::CSSIdentifierValue(EImageRendering e) |
2898 : CSSValue(IdentifierClass) { | 2898 : CSSValue(IdentifierClass) { |
2899 switch (e) { | 2899 switch (e) { |
2900 case ImageRenderingAuto: | 2900 case ImageRenderingAuto: |
2901 m_valueID = CSSValueAuto; | 2901 m_valueID = CSSValueAuto; |
2902 break; | 2902 break; |
(...skipping 22 matching lines...) Expand all Loading... |
2925 case CSSValueOptimizeQuality: | 2925 case CSSValueOptimizeQuality: |
2926 return ImageRenderingOptimizeQuality; | 2926 return ImageRenderingOptimizeQuality; |
2927 case CSSValuePixelated: | 2927 case CSSValuePixelated: |
2928 return ImageRenderingPixelated; | 2928 return ImageRenderingPixelated; |
2929 case CSSValueWebkitOptimizeContrast: | 2929 case CSSValueWebkitOptimizeContrast: |
2930 return ImageRenderingOptimizeContrast; | 2930 return ImageRenderingOptimizeContrast; |
2931 default: | 2931 default: |
2932 break; | 2932 break; |
2933 } | 2933 } |
2934 | 2934 |
2935 ASSERT_NOT_REACHED(); | 2935 NOTREACHED(); |
2936 return ImageRenderingAuto; | 2936 return ImageRenderingAuto; |
2937 } | 2937 } |
2938 | 2938 |
2939 template <> | 2939 template <> |
2940 inline CSSIdentifierValue::CSSIdentifierValue(ETransformStyle3D e) | 2940 inline CSSIdentifierValue::CSSIdentifierValue(ETransformStyle3D e) |
2941 : CSSValue(IdentifierClass) { | 2941 : CSSValue(IdentifierClass) { |
2942 switch (e) { | 2942 switch (e) { |
2943 case TransformStyle3DFlat: | 2943 case TransformStyle3DFlat: |
2944 m_valueID = CSSValueFlat; | 2944 m_valueID = CSSValueFlat; |
2945 break; | 2945 break; |
2946 case TransformStyle3DPreserve3D: | 2946 case TransformStyle3DPreserve3D: |
2947 m_valueID = CSSValuePreserve3d; | 2947 m_valueID = CSSValuePreserve3d; |
2948 break; | 2948 break; |
2949 } | 2949 } |
2950 } | 2950 } |
2951 | 2951 |
2952 template <> | 2952 template <> |
2953 inline ETransformStyle3D CSSIdentifierValue::convertTo() const { | 2953 inline ETransformStyle3D CSSIdentifierValue::convertTo() const { |
2954 switch (m_valueID) { | 2954 switch (m_valueID) { |
2955 case CSSValueFlat: | 2955 case CSSValueFlat: |
2956 return TransformStyle3DFlat; | 2956 return TransformStyle3DFlat; |
2957 case CSSValuePreserve3d: | 2957 case CSSValuePreserve3d: |
2958 return TransformStyle3DPreserve3D; | 2958 return TransformStyle3DPreserve3D; |
2959 default: | 2959 default: |
2960 break; | 2960 break; |
2961 } | 2961 } |
2962 | 2962 |
2963 ASSERT_NOT_REACHED(); | 2963 NOTREACHED(); |
2964 return TransformStyle3DFlat; | 2964 return TransformStyle3DFlat; |
2965 } | 2965 } |
2966 | 2966 |
2967 template <> | 2967 template <> |
2968 inline CSSIdentifierValue::CSSIdentifierValue(EBufferedRendering e) | 2968 inline CSSIdentifierValue::CSSIdentifierValue(EBufferedRendering e) |
2969 : CSSValue(IdentifierClass) { | 2969 : CSSValue(IdentifierClass) { |
2970 switch (e) { | 2970 switch (e) { |
2971 case BR_AUTO: | 2971 case BR_AUTO: |
2972 m_valueID = CSSValueAuto; | 2972 m_valueID = CSSValueAuto; |
2973 break; | 2973 break; |
(...skipping 12 matching lines...) Expand all Loading... |
2986 case CSSValueAuto: | 2986 case CSSValueAuto: |
2987 return BR_AUTO; | 2987 return BR_AUTO; |
2988 case CSSValueDynamic: | 2988 case CSSValueDynamic: |
2989 return BR_DYNAMIC; | 2989 return BR_DYNAMIC; |
2990 case CSSValueStatic: | 2990 case CSSValueStatic: |
2991 return BR_STATIC; | 2991 return BR_STATIC; |
2992 default: | 2992 default: |
2993 break; | 2993 break; |
2994 } | 2994 } |
2995 | 2995 |
2996 ASSERT_NOT_REACHED(); | 2996 NOTREACHED(); |
2997 return BR_AUTO; | 2997 return BR_AUTO; |
2998 } | 2998 } |
2999 | 2999 |
3000 template <> | 3000 template <> |
3001 inline CSSIdentifierValue::CSSIdentifierValue(EColorInterpolation e) | 3001 inline CSSIdentifierValue::CSSIdentifierValue(EColorInterpolation e) |
3002 : CSSValue(IdentifierClass) { | 3002 : CSSValue(IdentifierClass) { |
3003 switch (e) { | 3003 switch (e) { |
3004 case CI_AUTO: | 3004 case CI_AUTO: |
3005 m_valueID = CSSValueAuto; | 3005 m_valueID = CSSValueAuto; |
3006 break; | 3006 break; |
(...skipping 12 matching lines...) Expand all Loading... |
3019 case CSSValueSRGB: | 3019 case CSSValueSRGB: |
3020 return CI_SRGB; | 3020 return CI_SRGB; |
3021 case CSSValueLinearRGB: | 3021 case CSSValueLinearRGB: |
3022 return CI_LINEARRGB; | 3022 return CI_LINEARRGB; |
3023 case CSSValueAuto: | 3023 case CSSValueAuto: |
3024 return CI_AUTO; | 3024 return CI_AUTO; |
3025 default: | 3025 default: |
3026 break; | 3026 break; |
3027 } | 3027 } |
3028 | 3028 |
3029 ASSERT_NOT_REACHED(); | 3029 NOTREACHED(); |
3030 return CI_AUTO; | 3030 return CI_AUTO; |
3031 } | 3031 } |
3032 | 3032 |
3033 template <> | 3033 template <> |
3034 inline CSSIdentifierValue::CSSIdentifierValue(EColorRendering e) | 3034 inline CSSIdentifierValue::CSSIdentifierValue(EColorRendering e) |
3035 : CSSValue(IdentifierClass) { | 3035 : CSSValue(IdentifierClass) { |
3036 switch (e) { | 3036 switch (e) { |
3037 case CR_AUTO: | 3037 case CR_AUTO: |
3038 m_valueID = CSSValueAuto; | 3038 m_valueID = CSSValueAuto; |
3039 break; | 3039 break; |
(...skipping 12 matching lines...) Expand all Loading... |
3052 case CSSValueOptimizeSpeed: | 3052 case CSSValueOptimizeSpeed: |
3053 return CR_OPTIMIZESPEED; | 3053 return CR_OPTIMIZESPEED; |
3054 case CSSValueOptimizeQuality: | 3054 case CSSValueOptimizeQuality: |
3055 return CR_OPTIMIZEQUALITY; | 3055 return CR_OPTIMIZEQUALITY; |
3056 case CSSValueAuto: | 3056 case CSSValueAuto: |
3057 return CR_AUTO; | 3057 return CR_AUTO; |
3058 default: | 3058 default: |
3059 break; | 3059 break; |
3060 } | 3060 } |
3061 | 3061 |
3062 ASSERT_NOT_REACHED(); | 3062 NOTREACHED(); |
3063 return CR_AUTO; | 3063 return CR_AUTO; |
3064 } | 3064 } |
3065 | 3065 |
3066 template <> | 3066 template <> |
3067 inline CSSIdentifierValue::CSSIdentifierValue(EDominantBaseline e) | 3067 inline CSSIdentifierValue::CSSIdentifierValue(EDominantBaseline e) |
3068 : CSSValue(IdentifierClass) { | 3068 : CSSValue(IdentifierClass) { |
3069 switch (e) { | 3069 switch (e) { |
3070 case DB_AUTO: | 3070 case DB_AUTO: |
3071 m_valueID = CSSValueAuto; | 3071 m_valueID = CSSValueAuto; |
3072 break; | 3072 break; |
(...skipping 57 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3130 case CSSValueMiddle: | 3130 case CSSValueMiddle: |
3131 return DB_MIDDLE; | 3131 return DB_MIDDLE; |
3132 case CSSValueTextAfterEdge: | 3132 case CSSValueTextAfterEdge: |
3133 return DB_TEXT_AFTER_EDGE; | 3133 return DB_TEXT_AFTER_EDGE; |
3134 case CSSValueTextBeforeEdge: | 3134 case CSSValueTextBeforeEdge: |
3135 return DB_TEXT_BEFORE_EDGE; | 3135 return DB_TEXT_BEFORE_EDGE; |
3136 default: | 3136 default: |
3137 break; | 3137 break; |
3138 } | 3138 } |
3139 | 3139 |
3140 ASSERT_NOT_REACHED(); | 3140 NOTREACHED(); |
3141 return DB_AUTO; | 3141 return DB_AUTO; |
3142 } | 3142 } |
3143 | 3143 |
3144 template <> | 3144 template <> |
3145 inline CSSIdentifierValue::CSSIdentifierValue(EShapeRendering e) | 3145 inline CSSIdentifierValue::CSSIdentifierValue(EShapeRendering e) |
3146 : CSSValue(IdentifierClass) { | 3146 : CSSValue(IdentifierClass) { |
3147 switch (e) { | 3147 switch (e) { |
3148 case SR_AUTO: | 3148 case SR_AUTO: |
3149 m_valueID = CSSValueAuto; | 3149 m_valueID = CSSValueAuto; |
3150 break; | 3150 break; |
(...skipping 17 matching lines...) Expand all Loading... |
3168 case CSSValueOptimizeSpeed: | 3168 case CSSValueOptimizeSpeed: |
3169 return SR_OPTIMIZESPEED; | 3169 return SR_OPTIMIZESPEED; |
3170 case CSSValueCrispEdges: | 3170 case CSSValueCrispEdges: |
3171 return SR_CRISPEDGES; | 3171 return SR_CRISPEDGES; |
3172 case CSSValueGeometricPrecision: | 3172 case CSSValueGeometricPrecision: |
3173 return SR_GEOMETRICPRECISION; | 3173 return SR_GEOMETRICPRECISION; |
3174 default: | 3174 default: |
3175 break; | 3175 break; |
3176 } | 3176 } |
3177 | 3177 |
3178 ASSERT_NOT_REACHED(); | 3178 NOTREACHED(); |
3179 return SR_AUTO; | 3179 return SR_AUTO; |
3180 } | 3180 } |
3181 | 3181 |
3182 template <> | 3182 template <> |
3183 inline CSSIdentifierValue::CSSIdentifierValue(ETextAnchor e) | 3183 inline CSSIdentifierValue::CSSIdentifierValue(ETextAnchor e) |
3184 : CSSValue(IdentifierClass) { | 3184 : CSSValue(IdentifierClass) { |
3185 switch (e) { | 3185 switch (e) { |
3186 case TA_START: | 3186 case TA_START: |
3187 m_valueID = CSSValueStart; | 3187 m_valueID = CSSValueStart; |
3188 break; | 3188 break; |
(...skipping 12 matching lines...) Expand all Loading... |
3201 case CSSValueStart: | 3201 case CSSValueStart: |
3202 return TA_START; | 3202 return TA_START; |
3203 case CSSValueMiddle: | 3203 case CSSValueMiddle: |
3204 return TA_MIDDLE; | 3204 return TA_MIDDLE; |
3205 case CSSValueEnd: | 3205 case CSSValueEnd: |
3206 return TA_END; | 3206 return TA_END; |
3207 default: | 3207 default: |
3208 break; | 3208 break; |
3209 } | 3209 } |
3210 | 3210 |
3211 ASSERT_NOT_REACHED(); | 3211 NOTREACHED(); |
3212 return TA_START; | 3212 return TA_START; |
3213 } | 3213 } |
3214 | 3214 |
3215 template <> | 3215 template <> |
3216 inline CSSIdentifierValue::CSSIdentifierValue(EVectorEffect e) | 3216 inline CSSIdentifierValue::CSSIdentifierValue(EVectorEffect e) |
3217 : CSSValue(IdentifierClass) { | 3217 : CSSValue(IdentifierClass) { |
3218 switch (e) { | 3218 switch (e) { |
3219 case VE_NONE: | 3219 case VE_NONE: |
3220 m_valueID = CSSValueNone; | 3220 m_valueID = CSSValueNone; |
3221 break; | 3221 break; |
3222 case VE_NON_SCALING_STROKE: | 3222 case VE_NON_SCALING_STROKE: |
3223 m_valueID = CSSValueNonScalingStroke; | 3223 m_valueID = CSSValueNonScalingStroke; |
3224 break; | 3224 break; |
3225 } | 3225 } |
3226 } | 3226 } |
3227 | 3227 |
3228 template <> | 3228 template <> |
3229 inline EVectorEffect CSSIdentifierValue::convertTo() const { | 3229 inline EVectorEffect CSSIdentifierValue::convertTo() const { |
3230 switch (m_valueID) { | 3230 switch (m_valueID) { |
3231 case CSSValueNone: | 3231 case CSSValueNone: |
3232 return VE_NONE; | 3232 return VE_NONE; |
3233 case CSSValueNonScalingStroke: | 3233 case CSSValueNonScalingStroke: |
3234 return VE_NON_SCALING_STROKE; | 3234 return VE_NON_SCALING_STROKE; |
3235 default: | 3235 default: |
3236 break; | 3236 break; |
3237 } | 3237 } |
3238 | 3238 |
3239 ASSERT_NOT_REACHED(); | 3239 NOTREACHED(); |
3240 return VE_NONE; | 3240 return VE_NONE; |
3241 } | 3241 } |
3242 | 3242 |
3243 template <> | 3243 template <> |
3244 inline CSSIdentifierValue::CSSIdentifierValue(EPaintOrderType e) | 3244 inline CSSIdentifierValue::CSSIdentifierValue(EPaintOrderType e) |
3245 : CSSValue(IdentifierClass) { | 3245 : CSSValue(IdentifierClass) { |
3246 switch (e) { | 3246 switch (e) { |
3247 case PT_FILL: | 3247 case PT_FILL: |
3248 m_valueID = CSSValueFill; | 3248 m_valueID = CSSValueFill; |
3249 break; | 3249 break; |
3250 case PT_STROKE: | 3250 case PT_STROKE: |
3251 m_valueID = CSSValueStroke; | 3251 m_valueID = CSSValueStroke; |
3252 break; | 3252 break; |
3253 case PT_MARKERS: | 3253 case PT_MARKERS: |
3254 m_valueID = CSSValueMarkers; | 3254 m_valueID = CSSValueMarkers; |
3255 break; | 3255 break; |
3256 default: | 3256 default: |
3257 ASSERT_NOT_REACHED(); | 3257 NOTREACHED(); |
3258 m_valueID = CSSValueFill; | 3258 m_valueID = CSSValueFill; |
3259 break; | 3259 break; |
3260 } | 3260 } |
3261 } | 3261 } |
3262 | 3262 |
3263 template <> | 3263 template <> |
3264 inline EPaintOrderType CSSIdentifierValue::convertTo() const { | 3264 inline EPaintOrderType CSSIdentifierValue::convertTo() const { |
3265 switch (m_valueID) { | 3265 switch (m_valueID) { |
3266 case CSSValueFill: | 3266 case CSSValueFill: |
3267 return PT_FILL; | 3267 return PT_FILL; |
3268 case CSSValueStroke: | 3268 case CSSValueStroke: |
3269 return PT_STROKE; | 3269 return PT_STROKE; |
3270 case CSSValueMarkers: | 3270 case CSSValueMarkers: |
3271 return PT_MARKERS; | 3271 return PT_MARKERS; |
3272 default: | 3272 default: |
3273 break; | 3273 break; |
3274 } | 3274 } |
3275 | 3275 |
3276 ASSERT_NOT_REACHED(); | 3276 NOTREACHED(); |
3277 return PT_NONE; | 3277 return PT_NONE; |
3278 } | 3278 } |
3279 | 3279 |
3280 template <> | 3280 template <> |
3281 inline CSSIdentifierValue::CSSIdentifierValue(EMaskType e) | 3281 inline CSSIdentifierValue::CSSIdentifierValue(EMaskType e) |
3282 : CSSValue(IdentifierClass) { | 3282 : CSSValue(IdentifierClass) { |
3283 switch (e) { | 3283 switch (e) { |
3284 case MT_LUMINANCE: | 3284 case MT_LUMINANCE: |
3285 m_valueID = CSSValueLuminance; | 3285 m_valueID = CSSValueLuminance; |
3286 break; | 3286 break; |
3287 case MT_ALPHA: | 3287 case MT_ALPHA: |
3288 m_valueID = CSSValueAlpha; | 3288 m_valueID = CSSValueAlpha; |
3289 break; | 3289 break; |
3290 } | 3290 } |
3291 } | 3291 } |
3292 | 3292 |
3293 template <> | 3293 template <> |
3294 inline EMaskType CSSIdentifierValue::convertTo() const { | 3294 inline EMaskType CSSIdentifierValue::convertTo() const { |
3295 switch (m_valueID) { | 3295 switch (m_valueID) { |
3296 case CSSValueLuminance: | 3296 case CSSValueLuminance: |
3297 return MT_LUMINANCE; | 3297 return MT_LUMINANCE; |
3298 case CSSValueAlpha: | 3298 case CSSValueAlpha: |
3299 return MT_ALPHA; | 3299 return MT_ALPHA; |
3300 default: | 3300 default: |
3301 break; | 3301 break; |
3302 } | 3302 } |
3303 | 3303 |
3304 ASSERT_NOT_REACHED(); | 3304 NOTREACHED(); |
3305 return MT_LUMINANCE; | 3305 return MT_LUMINANCE; |
3306 } | 3306 } |
3307 | 3307 |
3308 template <> | 3308 template <> |
3309 inline TouchAction CSSIdentifierValue::convertTo() const { | 3309 inline TouchAction CSSIdentifierValue::convertTo() const { |
3310 switch (m_valueID) { | 3310 switch (m_valueID) { |
3311 case CSSValueNone: | 3311 case CSSValueNone: |
3312 return TouchActionNone; | 3312 return TouchActionNone; |
3313 case CSSValueAuto: | 3313 case CSSValueAuto: |
3314 return TouchActionAuto; | 3314 return TouchActionAuto; |
(...skipping 10 matching lines...) Expand all Loading... |
3325 case CSSValuePanY: | 3325 case CSSValuePanY: |
3326 return TouchActionPanY; | 3326 return TouchActionPanY; |
3327 case CSSValueManipulation: | 3327 case CSSValueManipulation: |
3328 return TouchActionManipulation; | 3328 return TouchActionManipulation; |
3329 case CSSValuePinchZoom: | 3329 case CSSValuePinchZoom: |
3330 return TouchActionPinchZoom; | 3330 return TouchActionPinchZoom; |
3331 default: | 3331 default: |
3332 break; | 3332 break; |
3333 } | 3333 } |
3334 | 3334 |
3335 ASSERT_NOT_REACHED(); | 3335 NOTREACHED(); |
3336 return TouchActionNone; | 3336 return TouchActionNone; |
3337 } | 3337 } |
3338 | 3338 |
3339 template <> | 3339 template <> |
3340 inline CSSIdentifierValue::CSSIdentifierValue(EIsolation i) | 3340 inline CSSIdentifierValue::CSSIdentifierValue(EIsolation i) |
3341 : CSSValue(IdentifierClass) { | 3341 : CSSValue(IdentifierClass) { |
3342 switch (i) { | 3342 switch (i) { |
3343 case IsolationAuto: | 3343 case IsolationAuto: |
3344 m_valueID = CSSValueAuto; | 3344 m_valueID = CSSValueAuto; |
3345 break; | 3345 break; |
3346 case IsolationIsolate: | 3346 case IsolationIsolate: |
3347 m_valueID = CSSValueIsolate; | 3347 m_valueID = CSSValueIsolate; |
3348 break; | 3348 break; |
3349 } | 3349 } |
3350 } | 3350 } |
3351 | 3351 |
3352 template <> | 3352 template <> |
3353 inline EIsolation CSSIdentifierValue::convertTo() const { | 3353 inline EIsolation CSSIdentifierValue::convertTo() const { |
3354 switch (m_valueID) { | 3354 switch (m_valueID) { |
3355 case CSSValueAuto: | 3355 case CSSValueAuto: |
3356 return IsolationAuto; | 3356 return IsolationAuto; |
3357 case CSSValueIsolate: | 3357 case CSSValueIsolate: |
3358 return IsolationIsolate; | 3358 return IsolationIsolate; |
3359 default: | 3359 default: |
3360 break; | 3360 break; |
3361 } | 3361 } |
3362 | 3362 |
3363 ASSERT_NOT_REACHED(); | 3363 NOTREACHED(); |
3364 return IsolationAuto; | 3364 return IsolationAuto; |
3365 } | 3365 } |
3366 | 3366 |
3367 template <> | 3367 template <> |
3368 inline CSSIdentifierValue::CSSIdentifierValue(CSSBoxType cssBox) | 3368 inline CSSIdentifierValue::CSSIdentifierValue(CSSBoxType cssBox) |
3369 : CSSValue(IdentifierClass) { | 3369 : CSSValue(IdentifierClass) { |
3370 switch (cssBox) { | 3370 switch (cssBox) { |
3371 case MarginBox: | 3371 case MarginBox: |
3372 m_valueID = CSSValueMarginBox; | 3372 m_valueID = CSSValueMarginBox; |
3373 break; | 3373 break; |
3374 case BorderBox: | 3374 case BorderBox: |
3375 m_valueID = CSSValueBorderBox; | 3375 m_valueID = CSSValueBorderBox; |
3376 break; | 3376 break; |
3377 case PaddingBox: | 3377 case PaddingBox: |
3378 m_valueID = CSSValuePaddingBox; | 3378 m_valueID = CSSValuePaddingBox; |
3379 break; | 3379 break; |
3380 case ContentBox: | 3380 case ContentBox: |
3381 m_valueID = CSSValueContentBox; | 3381 m_valueID = CSSValueContentBox; |
3382 break; | 3382 break; |
3383 case BoxMissing: | 3383 case BoxMissing: |
3384 // The missing box should convert to a null primitive value. | 3384 // The missing box should convert to a null primitive value. |
3385 ASSERT_NOT_REACHED(); | 3385 NOTREACHED(); |
3386 } | 3386 } |
3387 } | 3387 } |
3388 | 3388 |
3389 template <> | 3389 template <> |
3390 inline CSSBoxType CSSIdentifierValue::convertTo() const { | 3390 inline CSSBoxType CSSIdentifierValue::convertTo() const { |
3391 switch (getValueID()) { | 3391 switch (getValueID()) { |
3392 case CSSValueMarginBox: | 3392 case CSSValueMarginBox: |
3393 return MarginBox; | 3393 return MarginBox; |
3394 case CSSValueBorderBox: | 3394 case CSSValueBorderBox: |
3395 return BorderBox; | 3395 return BorderBox; |
3396 case CSSValuePaddingBox: | 3396 case CSSValuePaddingBox: |
3397 return PaddingBox; | 3397 return PaddingBox; |
3398 case CSSValueContentBox: | 3398 case CSSValueContentBox: |
3399 return ContentBox; | 3399 return ContentBox; |
3400 default: | 3400 default: |
3401 break; | 3401 break; |
3402 } | 3402 } |
3403 ASSERT_NOT_REACHED(); | 3403 NOTREACHED(); |
3404 return ContentBox; | 3404 return ContentBox; |
3405 } | 3405 } |
3406 | 3406 |
3407 template <> | 3407 template <> |
3408 inline CSSIdentifierValue::CSSIdentifierValue(ItemPosition itemPosition) | 3408 inline CSSIdentifierValue::CSSIdentifierValue(ItemPosition itemPosition) |
3409 : CSSValue(IdentifierClass) { | 3409 : CSSValue(IdentifierClass) { |
3410 switch (itemPosition) { | 3410 switch (itemPosition) { |
3411 case ItemPositionAuto: | 3411 case ItemPositionAuto: |
3412 // The 'auto' values might have been already resolved. | 3412 // The 'auto' values might have been already resolved. |
3413 NOTREACHED(); | 3413 NOTREACHED(); |
(...skipping 68 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3482 return ItemPositionFlexStart; | 3482 return ItemPositionFlexStart; |
3483 case CSSValueFlexEnd: | 3483 case CSSValueFlexEnd: |
3484 return ItemPositionFlexEnd; | 3484 return ItemPositionFlexEnd; |
3485 case CSSValueLeft: | 3485 case CSSValueLeft: |
3486 return ItemPositionLeft; | 3486 return ItemPositionLeft; |
3487 case CSSValueRight: | 3487 case CSSValueRight: |
3488 return ItemPositionRight; | 3488 return ItemPositionRight; |
3489 default: | 3489 default: |
3490 break; | 3490 break; |
3491 } | 3491 } |
3492 ASSERT_NOT_REACHED(); | 3492 NOTREACHED(); |
3493 return ItemPositionAuto; | 3493 return ItemPositionAuto; |
3494 } | 3494 } |
3495 | 3495 |
3496 template <> | 3496 template <> |
3497 inline CSSIdentifierValue::CSSIdentifierValue(ContentPosition contentPosition) | 3497 inline CSSIdentifierValue::CSSIdentifierValue(ContentPosition contentPosition) |
3498 : CSSValue(IdentifierClass) { | 3498 : CSSValue(IdentifierClass) { |
3499 switch (contentPosition) { | 3499 switch (contentPosition) { |
3500 case ContentPositionNormal: | 3500 case ContentPositionNormal: |
3501 m_valueID = CSSValueNormal; | 3501 m_valueID = CSSValueNormal; |
3502 break; | 3502 break; |
(...skipping 46 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3549 return ContentPositionFlexStart; | 3549 return ContentPositionFlexStart; |
3550 case CSSValueFlexEnd: | 3550 case CSSValueFlexEnd: |
3551 return ContentPositionFlexEnd; | 3551 return ContentPositionFlexEnd; |
3552 case CSSValueLeft: | 3552 case CSSValueLeft: |
3553 return ContentPositionLeft; | 3553 return ContentPositionLeft; |
3554 case CSSValueRight: | 3554 case CSSValueRight: |
3555 return ContentPositionRight; | 3555 return ContentPositionRight; |
3556 default: | 3556 default: |
3557 break; | 3557 break; |
3558 } | 3558 } |
3559 ASSERT_NOT_REACHED(); | 3559 NOTREACHED(); |
3560 return ContentPositionNormal; | 3560 return ContentPositionNormal; |
3561 } | 3561 } |
3562 | 3562 |
3563 template <> | 3563 template <> |
3564 inline CSSIdentifierValue::CSSIdentifierValue( | 3564 inline CSSIdentifierValue::CSSIdentifierValue( |
3565 ContentDistributionType contentDistribution) | 3565 ContentDistributionType contentDistribution) |
3566 : CSSValue(IdentifierClass) { | 3566 : CSSValue(IdentifierClass) { |
3567 switch (contentDistribution) { | 3567 switch (contentDistribution) { |
3568 case ContentDistributionDefault: | 3568 case ContentDistributionDefault: |
3569 m_valueID = CSSValueDefault; | 3569 m_valueID = CSSValueDefault; |
(...skipping 20 matching lines...) Expand all Loading... |
3590 return ContentDistributionSpaceBetween; | 3590 return ContentDistributionSpaceBetween; |
3591 case CSSValueSpaceAround: | 3591 case CSSValueSpaceAround: |
3592 return ContentDistributionSpaceAround; | 3592 return ContentDistributionSpaceAround; |
3593 case CSSValueSpaceEvenly: | 3593 case CSSValueSpaceEvenly: |
3594 return ContentDistributionSpaceEvenly; | 3594 return ContentDistributionSpaceEvenly; |
3595 case CSSValueStretch: | 3595 case CSSValueStretch: |
3596 return ContentDistributionStretch; | 3596 return ContentDistributionStretch; |
3597 default: | 3597 default: |
3598 break; | 3598 break; |
3599 } | 3599 } |
3600 ASSERT_NOT_REACHED(); | 3600 NOTREACHED(); |
3601 return ContentDistributionStretch; | 3601 return ContentDistributionStretch; |
3602 } | 3602 } |
3603 | 3603 |
3604 template <> | 3604 template <> |
3605 inline CSSIdentifierValue::CSSIdentifierValue( | 3605 inline CSSIdentifierValue::CSSIdentifierValue( |
3606 OverflowAlignment overflowAlignment) | 3606 OverflowAlignment overflowAlignment) |
3607 : CSSValue(IdentifierClass) { | 3607 : CSSValue(IdentifierClass) { |
3608 switch (overflowAlignment) { | 3608 switch (overflowAlignment) { |
3609 case OverflowAlignmentDefault: | 3609 case OverflowAlignmentDefault: |
3610 m_valueID = CSSValueDefault; | 3610 m_valueID = CSSValueDefault; |
(...skipping 10 matching lines...) Expand all Loading... |
3621 template <> | 3621 template <> |
3622 inline OverflowAlignment CSSIdentifierValue::convertTo() const { | 3622 inline OverflowAlignment CSSIdentifierValue::convertTo() const { |
3623 switch (m_valueID) { | 3623 switch (m_valueID) { |
3624 case CSSValueUnsafe: | 3624 case CSSValueUnsafe: |
3625 return OverflowAlignmentUnsafe; | 3625 return OverflowAlignmentUnsafe; |
3626 case CSSValueSafe: | 3626 case CSSValueSafe: |
3627 return OverflowAlignmentSafe; | 3627 return OverflowAlignmentSafe; |
3628 default: | 3628 default: |
3629 break; | 3629 break; |
3630 } | 3630 } |
3631 ASSERT_NOT_REACHED(); | 3631 NOTREACHED(); |
3632 return OverflowAlignmentUnsafe; | 3632 return OverflowAlignmentUnsafe; |
3633 } | 3633 } |
3634 | 3634 |
3635 template <> | 3635 template <> |
3636 inline CSSIdentifierValue::CSSIdentifierValue(ScrollBehavior behavior) | 3636 inline CSSIdentifierValue::CSSIdentifierValue(ScrollBehavior behavior) |
3637 : CSSValue(IdentifierClass) { | 3637 : CSSValue(IdentifierClass) { |
3638 switch (behavior) { | 3638 switch (behavior) { |
3639 case ScrollBehaviorAuto: | 3639 case ScrollBehaviorAuto: |
3640 m_valueID = CSSValueAuto; | 3640 m_valueID = CSSValueAuto; |
3641 break; | 3641 break; |
3642 case ScrollBehaviorSmooth: | 3642 case ScrollBehaviorSmooth: |
3643 m_valueID = CSSValueSmooth; | 3643 m_valueID = CSSValueSmooth; |
3644 break; | 3644 break; |
3645 case ScrollBehaviorInstant: | 3645 case ScrollBehaviorInstant: |
3646 // Behavior 'instant' is only allowed in ScrollOptions arguments passed to | 3646 // Behavior 'instant' is only allowed in ScrollOptions arguments passed to |
3647 // CSSOM scroll APIs. | 3647 // CSSOM scroll APIs. |
3648 ASSERT_NOT_REACHED(); | 3648 NOTREACHED(); |
3649 } | 3649 } |
3650 } | 3650 } |
3651 | 3651 |
3652 template <> | 3652 template <> |
3653 inline ScrollBehavior CSSIdentifierValue::convertTo() const { | 3653 inline ScrollBehavior CSSIdentifierValue::convertTo() const { |
3654 switch (getValueID()) { | 3654 switch (getValueID()) { |
3655 case CSSValueAuto: | 3655 case CSSValueAuto: |
3656 return ScrollBehaviorAuto; | 3656 return ScrollBehaviorAuto; |
3657 case CSSValueSmooth: | 3657 case CSSValueSmooth: |
3658 return ScrollBehaviorSmooth; | 3658 return ScrollBehaviorSmooth; |
3659 default: | 3659 default: |
3660 break; | 3660 break; |
3661 } | 3661 } |
3662 ASSERT_NOT_REACHED(); | 3662 NOTREACHED(); |
3663 return ScrollBehaviorAuto; | 3663 return ScrollBehaviorAuto; |
3664 } | 3664 } |
3665 | 3665 |
3666 template <> | 3666 template <> |
3667 inline CSSIdentifierValue::CSSIdentifierValue(ScrollSnapType snapType) | 3667 inline CSSIdentifierValue::CSSIdentifierValue(ScrollSnapType snapType) |
3668 : CSSValue(IdentifierClass) { | 3668 : CSSValue(IdentifierClass) { |
3669 switch (snapType) { | 3669 switch (snapType) { |
3670 case ScrollSnapTypeNone: | 3670 case ScrollSnapTypeNone: |
3671 m_valueID = CSSValueNone; | 3671 m_valueID = CSSValueNone; |
3672 break; | 3672 break; |
(...skipping 11 matching lines...) Expand all Loading... |
3684 switch (getValueID()) { | 3684 switch (getValueID()) { |
3685 case CSSValueNone: | 3685 case CSSValueNone: |
3686 return ScrollSnapTypeNone; | 3686 return ScrollSnapTypeNone; |
3687 case CSSValueMandatory: | 3687 case CSSValueMandatory: |
3688 return ScrollSnapTypeMandatory; | 3688 return ScrollSnapTypeMandatory; |
3689 case CSSValueProximity: | 3689 case CSSValueProximity: |
3690 return ScrollSnapTypeProximity; | 3690 return ScrollSnapTypeProximity; |
3691 default: | 3691 default: |
3692 break; | 3692 break; |
3693 } | 3693 } |
3694 ASSERT_NOT_REACHED(); | 3694 NOTREACHED(); |
3695 return ScrollSnapTypeNone; | 3695 return ScrollSnapTypeNone; |
3696 } | 3696 } |
3697 | 3697 |
3698 template <> | 3698 template <> |
3699 inline CSSIdentifierValue::CSSIdentifierValue(Containment snapType) | 3699 inline CSSIdentifierValue::CSSIdentifierValue(Containment snapType) |
3700 : CSSValue(IdentifierClass) { | 3700 : CSSValue(IdentifierClass) { |
3701 switch (snapType) { | 3701 switch (snapType) { |
3702 case ContainsNone: | 3702 case ContainsNone: |
3703 m_valueID = CSSValueNone; | 3703 m_valueID = CSSValueNone; |
3704 break; | 3704 break; |
(...skipping 31 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3736 return ContainsPaint; | 3736 return ContainsPaint; |
3737 case CSSValueStyle: | 3737 case CSSValueStyle: |
3738 return ContainsStyle; | 3738 return ContainsStyle; |
3739 case CSSValueLayout: | 3739 case CSSValueLayout: |
3740 return ContainsLayout; | 3740 return ContainsLayout; |
3741 case CSSValueSize: | 3741 case CSSValueSize: |
3742 return ContainsSize; | 3742 return ContainsSize; |
3743 default: | 3743 default: |
3744 break; | 3744 break; |
3745 } | 3745 } |
3746 ASSERT_NOT_REACHED(); | 3746 NOTREACHED(); |
3747 return ContainsNone; | 3747 return ContainsNone; |
3748 } | 3748 } |
3749 | 3749 |
3750 } // namespace blink | 3750 } // namespace blink |
3751 | 3751 |
3752 #endif | 3752 #endif |
OLD | NEW |