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 168 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
502 inline EBackfaceVisibility CSSIdentifierValue::convertTo() const { | 502 inline EBackfaceVisibility CSSIdentifierValue::convertTo() const { |
503 switch (m_valueID) { | 503 switch (m_valueID) { |
504 case CSSValueVisible: | 504 case CSSValueVisible: |
505 return BackfaceVisibilityVisible; | 505 return BackfaceVisibilityVisible; |
506 case CSSValueHidden: | 506 case CSSValueHidden: |
507 return BackfaceVisibilityHidden; | 507 return BackfaceVisibilityHidden; |
508 default: | 508 default: |
509 break; | 509 break; |
510 } | 510 } |
511 | 511 |
512 ASSERT_NOT_REACHED(); | 512 NOTREACHED(); |
513 return BackfaceVisibilityHidden; | 513 return BackfaceVisibilityHidden; |
514 } | 514 } |
515 | 515 |
516 template <> | 516 template <> |
517 inline CSSIdentifierValue::CSSIdentifierValue(EFillAttachment e) | 517 inline CSSIdentifierValue::CSSIdentifierValue(EFillAttachment e) |
518 : CSSValue(IdentifierClass) { | 518 : CSSValue(IdentifierClass) { |
519 switch (e) { | 519 switch (e) { |
520 case ScrollBackgroundAttachment: | 520 case ScrollBackgroundAttachment: |
521 m_valueID = CSSValueScroll; | 521 m_valueID = CSSValueScroll; |
522 break; | 522 break; |
(...skipping 12 matching lines...) Expand all Loading... |
535 case CSSValueScroll: | 535 case CSSValueScroll: |
536 return ScrollBackgroundAttachment; | 536 return ScrollBackgroundAttachment; |
537 case CSSValueLocal: | 537 case CSSValueLocal: |
538 return LocalBackgroundAttachment; | 538 return LocalBackgroundAttachment; |
539 case CSSValueFixed: | 539 case CSSValueFixed: |
540 return FixedBackgroundAttachment; | 540 return FixedBackgroundAttachment; |
541 default: | 541 default: |
542 break; | 542 break; |
543 } | 543 } |
544 | 544 |
545 ASSERT_NOT_REACHED(); | 545 NOTREACHED(); |
546 return ScrollBackgroundAttachment; | 546 return ScrollBackgroundAttachment; |
547 } | 547 } |
548 | 548 |
549 template <> | 549 template <> |
550 inline CSSIdentifierValue::CSSIdentifierValue(EFillBox e) | 550 inline CSSIdentifierValue::CSSIdentifierValue(EFillBox e) |
551 : CSSValue(IdentifierClass) { | 551 : CSSValue(IdentifierClass) { |
552 switch (e) { | 552 switch (e) { |
553 case BorderFillBox: | 553 case BorderFillBox: |
554 m_valueID = CSSValueBorderBox; | 554 m_valueID = CSSValueBorderBox; |
555 break; | 555 break; |
(...skipping 20 matching lines...) Expand all Loading... |
576 return PaddingFillBox; | 576 return PaddingFillBox; |
577 case CSSValueContent: | 577 case CSSValueContent: |
578 case CSSValueContentBox: | 578 case CSSValueContentBox: |
579 return ContentFillBox; | 579 return ContentFillBox; |
580 case CSSValueText: | 580 case CSSValueText: |
581 return TextFillBox; | 581 return TextFillBox; |
582 default: | 582 default: |
583 break; | 583 break; |
584 } | 584 } |
585 | 585 |
586 ASSERT_NOT_REACHED(); | 586 NOTREACHED(); |
587 return BorderFillBox; | 587 return BorderFillBox; |
588 } | 588 } |
589 | 589 |
590 template <> | 590 template <> |
591 inline CSSIdentifierValue::CSSIdentifierValue(EFillRepeat e) | 591 inline CSSIdentifierValue::CSSIdentifierValue(EFillRepeat e) |
592 : CSSValue(IdentifierClass) { | 592 : CSSValue(IdentifierClass) { |
593 switch (e) { | 593 switch (e) { |
594 case RepeatFill: | 594 case RepeatFill: |
595 m_valueID = CSSValueRepeat; | 595 m_valueID = CSSValueRepeat; |
596 break; | 596 break; |
(...skipping 17 matching lines...) Expand all Loading... |
614 case CSSValueNoRepeat: | 614 case CSSValueNoRepeat: |
615 return NoRepeatFill; | 615 return NoRepeatFill; |
616 case CSSValueRound: | 616 case CSSValueRound: |
617 return RoundFill; | 617 return RoundFill; |
618 case CSSValueSpace: | 618 case CSSValueSpace: |
619 return SpaceFill; | 619 return SpaceFill; |
620 default: | 620 default: |
621 break; | 621 break; |
622 } | 622 } |
623 | 623 |
624 ASSERT_NOT_REACHED(); | 624 NOTREACHED(); |
625 return RepeatFill; | 625 return RepeatFill; |
626 } | 626 } |
627 | 627 |
628 template <> | 628 template <> |
629 inline CSSIdentifierValue::CSSIdentifierValue(EBoxPack e) | 629 inline CSSIdentifierValue::CSSIdentifierValue(EBoxPack e) |
630 : CSSValue(IdentifierClass) { | 630 : CSSValue(IdentifierClass) { |
631 switch (e) { | 631 switch (e) { |
632 case BoxPackStart: | 632 case BoxPackStart: |
633 m_valueID = CSSValueStart; | 633 m_valueID = CSSValueStart; |
634 break; | 634 break; |
(...skipping 17 matching lines...) Expand all Loading... |
652 case CSSValueEnd: | 652 case CSSValueEnd: |
653 return BoxPackEnd; | 653 return BoxPackEnd; |
654 case CSSValueCenter: | 654 case CSSValueCenter: |
655 return BoxPackCenter; | 655 return BoxPackCenter; |
656 case CSSValueJustify: | 656 case CSSValueJustify: |
657 return BoxPackJustify; | 657 return BoxPackJustify; |
658 default: | 658 default: |
659 break; | 659 break; |
660 } | 660 } |
661 | 661 |
662 ASSERT_NOT_REACHED(); | 662 NOTREACHED(); |
663 return BoxPackJustify; | 663 return BoxPackJustify; |
664 } | 664 } |
665 | 665 |
666 template <> | 666 template <> |
667 inline CSSIdentifierValue::CSSIdentifierValue(EBoxAlignment e) | 667 inline CSSIdentifierValue::CSSIdentifierValue(EBoxAlignment e) |
668 : CSSValue(IdentifierClass) { | 668 : CSSValue(IdentifierClass) { |
669 switch (e) { | 669 switch (e) { |
670 case BSTRETCH: | 670 case BSTRETCH: |
671 m_valueID = CSSValueStretch; | 671 m_valueID = CSSValueStretch; |
672 break; | 672 break; |
(...skipping 22 matching lines...) Expand all Loading... |
695 case CSSValueEnd: | 695 case CSSValueEnd: |
696 return BEND; | 696 return BEND; |
697 case CSSValueCenter: | 697 case CSSValueCenter: |
698 return BCENTER; | 698 return BCENTER; |
699 case CSSValueBaseline: | 699 case CSSValueBaseline: |
700 return BBASELINE; | 700 return BBASELINE; |
701 default: | 701 default: |
702 break; | 702 break; |
703 } | 703 } |
704 | 704 |
705 ASSERT_NOT_REACHED(); | 705 NOTREACHED(); |
706 return BSTRETCH; | 706 return BSTRETCH; |
707 } | 707 } |
708 | 708 |
709 template <> | 709 template <> |
710 inline CSSIdentifierValue::CSSIdentifierValue(EBoxDecorationBreak e) | 710 inline CSSIdentifierValue::CSSIdentifierValue(EBoxDecorationBreak e) |
711 : CSSValue(IdentifierClass) { | 711 : CSSValue(IdentifierClass) { |
712 switch (e) { | 712 switch (e) { |
713 case BoxDecorationBreakSlice: | 713 case BoxDecorationBreakSlice: |
714 m_valueID = CSSValueSlice; | 714 m_valueID = CSSValueSlice; |
715 break; | 715 break; |
716 case BoxDecorationBreakClone: | 716 case BoxDecorationBreakClone: |
717 m_valueID = CSSValueClone; | 717 m_valueID = CSSValueClone; |
718 break; | 718 break; |
719 } | 719 } |
720 } | 720 } |
721 | 721 |
722 template <> | 722 template <> |
723 inline EBoxDecorationBreak CSSIdentifierValue::convertTo() const { | 723 inline EBoxDecorationBreak CSSIdentifierValue::convertTo() const { |
724 switch (m_valueID) { | 724 switch (m_valueID) { |
725 case CSSValueSlice: | 725 case CSSValueSlice: |
726 return BoxDecorationBreakSlice; | 726 return BoxDecorationBreakSlice; |
727 case CSSValueClone: | 727 case CSSValueClone: |
728 return BoxDecorationBreakClone; | 728 return BoxDecorationBreakClone; |
729 default: | 729 default: |
730 break; | 730 break; |
731 } | 731 } |
732 | 732 |
733 ASSERT_NOT_REACHED(); | 733 NOTREACHED(); |
734 return BoxDecorationBreakSlice; | 734 return BoxDecorationBreakSlice; |
735 } | 735 } |
736 | 736 |
737 template <> | 737 template <> |
738 inline CSSIdentifierValue::CSSIdentifierValue(BackgroundEdgeOrigin e) | 738 inline CSSIdentifierValue::CSSIdentifierValue(BackgroundEdgeOrigin e) |
739 : CSSValue(IdentifierClass) { | 739 : CSSValue(IdentifierClass) { |
740 switch (e) { | 740 switch (e) { |
741 case TopEdge: | 741 case TopEdge: |
742 m_valueID = CSSValueTop; | 742 m_valueID = CSSValueTop; |
743 break; | 743 break; |
(...skipping 17 matching lines...) Expand all Loading... |
761 case CSSValueRight: | 761 case CSSValueRight: |
762 return RightEdge; | 762 return RightEdge; |
763 case CSSValueBottom: | 763 case CSSValueBottom: |
764 return BottomEdge; | 764 return BottomEdge; |
765 case CSSValueLeft: | 765 case CSSValueLeft: |
766 return LeftEdge; | 766 return LeftEdge; |
767 default: | 767 default: |
768 break; | 768 break; |
769 } | 769 } |
770 | 770 |
771 ASSERT_NOT_REACHED(); | 771 NOTREACHED(); |
772 return TopEdge; | 772 return TopEdge; |
773 } | 773 } |
774 | 774 |
775 template <> | 775 template <> |
776 inline CSSIdentifierValue::CSSIdentifierValue(EBoxSizing e) | 776 inline CSSIdentifierValue::CSSIdentifierValue(EBoxSizing e) |
777 : CSSValue(IdentifierClass) { | 777 : CSSValue(IdentifierClass) { |
778 switch (e) { | 778 switch (e) { |
779 case EBoxSizing::kBorderBox: | 779 case EBoxSizing::kBorderBox: |
780 m_valueID = CSSValueBorderBox; | 780 m_valueID = CSSValueBorderBox; |
781 break; | 781 break; |
782 case EBoxSizing::kContentBox: | 782 case EBoxSizing::kContentBox: |
783 m_valueID = CSSValueContentBox; | 783 m_valueID = CSSValueContentBox; |
784 break; | 784 break; |
785 } | 785 } |
786 } | 786 } |
787 | 787 |
788 template <> | 788 template <> |
789 inline EBoxSizing CSSIdentifierValue::convertTo() const { | 789 inline EBoxSizing CSSIdentifierValue::convertTo() const { |
790 switch (m_valueID) { | 790 switch (m_valueID) { |
791 case CSSValueBorderBox: | 791 case CSSValueBorderBox: |
792 return EBoxSizing::kBorderBox; | 792 return EBoxSizing::kBorderBox; |
793 case CSSValueContentBox: | 793 case CSSValueContentBox: |
794 return EBoxSizing::kContentBox; | 794 return EBoxSizing::kContentBox; |
795 default: | 795 default: |
796 break; | 796 break; |
797 } | 797 } |
798 | 798 |
799 ASSERT_NOT_REACHED(); | 799 NOTREACHED(); |
800 return EBoxSizing::kBorderBox; | 800 return EBoxSizing::kBorderBox; |
801 } | 801 } |
802 | 802 |
803 template <> | 803 template <> |
804 inline CSSIdentifierValue::CSSIdentifierValue(EBoxLines e) | 804 inline CSSIdentifierValue::CSSIdentifierValue(EBoxLines e) |
805 : CSSValue(IdentifierClass) { | 805 : CSSValue(IdentifierClass) { |
806 switch (e) { | 806 switch (e) { |
807 case SINGLE: | 807 case SINGLE: |
808 m_valueID = CSSValueSingle; | 808 m_valueID = CSSValueSingle; |
809 break; | 809 break; |
810 case MULTIPLE: | 810 case MULTIPLE: |
811 m_valueID = CSSValueMultiple; | 811 m_valueID = CSSValueMultiple; |
812 break; | 812 break; |
813 } | 813 } |
814 } | 814 } |
815 | 815 |
816 template <> | 816 template <> |
817 inline EBoxLines CSSIdentifierValue::convertTo() const { | 817 inline EBoxLines CSSIdentifierValue::convertTo() const { |
818 switch (m_valueID) { | 818 switch (m_valueID) { |
819 case CSSValueSingle: | 819 case CSSValueSingle: |
820 return SINGLE; | 820 return SINGLE; |
821 case CSSValueMultiple: | 821 case CSSValueMultiple: |
822 return MULTIPLE; | 822 return MULTIPLE; |
823 default: | 823 default: |
824 break; | 824 break; |
825 } | 825 } |
826 | 826 |
827 ASSERT_NOT_REACHED(); | 827 NOTREACHED(); |
828 return SINGLE; | 828 return SINGLE; |
829 } | 829 } |
830 | 830 |
831 template <> | 831 template <> |
832 inline CSSIdentifierValue::CSSIdentifierValue(EBoxOrient e) | 832 inline CSSIdentifierValue::CSSIdentifierValue(EBoxOrient e) |
833 : CSSValue(IdentifierClass) { | 833 : CSSValue(IdentifierClass) { |
834 switch (e) { | 834 switch (e) { |
835 case HORIZONTAL: | 835 case HORIZONTAL: |
836 m_valueID = CSSValueHorizontal; | 836 m_valueID = CSSValueHorizontal; |
837 break; | 837 break; |
838 case VERTICAL: | 838 case VERTICAL: |
839 m_valueID = CSSValueVertical; | 839 m_valueID = CSSValueVertical; |
840 break; | 840 break; |
841 } | 841 } |
842 } | 842 } |
843 | 843 |
844 template <> | 844 template <> |
845 inline EBoxOrient CSSIdentifierValue::convertTo() const { | 845 inline EBoxOrient CSSIdentifierValue::convertTo() const { |
846 switch (m_valueID) { | 846 switch (m_valueID) { |
847 case CSSValueHorizontal: | 847 case CSSValueHorizontal: |
848 case CSSValueInlineAxis: | 848 case CSSValueInlineAxis: |
849 return HORIZONTAL; | 849 return HORIZONTAL; |
850 case CSSValueVertical: | 850 case CSSValueVertical: |
851 case CSSValueBlockAxis: | 851 case CSSValueBlockAxis: |
852 return VERTICAL; | 852 return VERTICAL; |
853 default: | 853 default: |
854 break; | 854 break; |
855 } | 855 } |
856 | 856 |
857 ASSERT_NOT_REACHED(); | 857 NOTREACHED(); |
858 return HORIZONTAL; | 858 return HORIZONTAL; |
859 } | 859 } |
860 | 860 |
861 template <> | 861 template <> |
862 inline CSSIdentifierValue::CSSIdentifierValue(EFlexDirection e) | 862 inline CSSIdentifierValue::CSSIdentifierValue(EFlexDirection e) |
863 : CSSValue(IdentifierClass) { | 863 : CSSValue(IdentifierClass) { |
864 switch (e) { | 864 switch (e) { |
865 case FlowRow: | 865 case FlowRow: |
866 m_valueID = CSSValueRow; | 866 m_valueID = CSSValueRow; |
867 break; | 867 break; |
(...skipping 17 matching lines...) Expand all Loading... |
885 case CSSValueRowReverse: | 885 case CSSValueRowReverse: |
886 return FlowRowReverse; | 886 return FlowRowReverse; |
887 case CSSValueColumn: | 887 case CSSValueColumn: |
888 return FlowColumn; | 888 return FlowColumn; |
889 case CSSValueColumnReverse: | 889 case CSSValueColumnReverse: |
890 return FlowColumnReverse; | 890 return FlowColumnReverse; |
891 default: | 891 default: |
892 break; | 892 break; |
893 } | 893 } |
894 | 894 |
895 ASSERT_NOT_REACHED(); | 895 NOTREACHED(); |
896 return FlowRow; | 896 return FlowRow; |
897 } | 897 } |
898 | 898 |
899 template <> | 899 template <> |
900 inline CSSIdentifierValue::CSSIdentifierValue(EFlexWrap e) | 900 inline CSSIdentifierValue::CSSIdentifierValue(EFlexWrap e) |
901 : CSSValue(IdentifierClass) { | 901 : CSSValue(IdentifierClass) { |
902 switch (e) { | 902 switch (e) { |
903 case FlexNoWrap: | 903 case FlexNoWrap: |
904 m_valueID = CSSValueNowrap; | 904 m_valueID = CSSValueNowrap; |
905 break; | 905 break; |
(...skipping 12 matching lines...) Expand all Loading... |
918 case CSSValueNowrap: | 918 case CSSValueNowrap: |
919 return FlexNoWrap; | 919 return FlexNoWrap; |
920 case CSSValueWrap: | 920 case CSSValueWrap: |
921 return FlexWrap; | 921 return FlexWrap; |
922 case CSSValueWrapReverse: | 922 case CSSValueWrapReverse: |
923 return FlexWrapReverse; | 923 return FlexWrapReverse; |
924 default: | 924 default: |
925 break; | 925 break; |
926 } | 926 } |
927 | 927 |
928 ASSERT_NOT_REACHED(); | 928 NOTREACHED(); |
929 return FlexNoWrap; | 929 return FlexNoWrap; |
930 } | 930 } |
931 | 931 |
932 template <> | 932 template <> |
933 inline CSSIdentifierValue::CSSIdentifierValue(EFloat e) | 933 inline CSSIdentifierValue::CSSIdentifierValue(EFloat e) |
934 : CSSValue(IdentifierClass) { | 934 : CSSValue(IdentifierClass) { |
935 switch (e) { | 935 switch (e) { |
936 case EFloat::kNone: | 936 case EFloat::kNone: |
937 m_valueID = CSSValueNone; | 937 m_valueID = CSSValueNone; |
938 break; | 938 break; |
(...skipping 12 matching lines...) Expand all Loading... |
951 case CSSValueLeft: | 951 case CSSValueLeft: |
952 return EFloat::kLeft; | 952 return EFloat::kLeft; |
953 case CSSValueRight: | 953 case CSSValueRight: |
954 return EFloat::kRight; | 954 return EFloat::kRight; |
955 case CSSValueNone: | 955 case CSSValueNone: |
956 return EFloat::kNone; | 956 return EFloat::kNone; |
957 default: | 957 default: |
958 break; | 958 break; |
959 } | 959 } |
960 | 960 |
961 ASSERT_NOT_REACHED(); | 961 NOTREACHED(); |
962 return EFloat::kNone; | 962 return EFloat::kNone; |
963 } | 963 } |
964 | 964 |
965 template <> | 965 template <> |
966 inline CSSIdentifierValue::CSSIdentifierValue(Hyphens e) | 966 inline CSSIdentifierValue::CSSIdentifierValue(Hyphens e) |
967 : CSSValue(IdentifierClass) { | 967 : CSSValue(IdentifierClass) { |
968 switch (e) { | 968 switch (e) { |
969 case HyphensAuto: | 969 case HyphensAuto: |
970 m_valueID = CSSValueAuto; | 970 m_valueID = CSSValueAuto; |
971 break; | 971 break; |
(...skipping 55 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1027 case CSSValueNormal: | 1027 case CSSValueNormal: |
1028 return LineBreakNormal; | 1028 return LineBreakNormal; |
1029 case CSSValueStrict: | 1029 case CSSValueStrict: |
1030 return LineBreakStrict; | 1030 return LineBreakStrict; |
1031 case CSSValueAfterWhiteSpace: | 1031 case CSSValueAfterWhiteSpace: |
1032 return LineBreakAfterWhiteSpace; | 1032 return LineBreakAfterWhiteSpace; |
1033 default: | 1033 default: |
1034 break; | 1034 break; |
1035 } | 1035 } |
1036 | 1036 |
1037 ASSERT_NOT_REACHED(); | 1037 NOTREACHED(); |
1038 return LineBreakAuto; | 1038 return LineBreakAuto; |
1039 } | 1039 } |
1040 | 1040 |
1041 template <> | 1041 template <> |
1042 inline CSSIdentifierValue::CSSIdentifierValue(EMarginCollapse e) | 1042 inline CSSIdentifierValue::CSSIdentifierValue(EMarginCollapse e) |
1043 : CSSValue(IdentifierClass) { | 1043 : CSSValue(IdentifierClass) { |
1044 switch (e) { | 1044 switch (e) { |
1045 case MarginCollapseCollapse: | 1045 case MarginCollapseCollapse: |
1046 m_valueID = CSSValueCollapse; | 1046 m_valueID = CSSValueCollapse; |
1047 break; | 1047 break; |
(...skipping 55 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1103 case CSSValueAbsolute: | 1103 case CSSValueAbsolute: |
1104 return EPosition::kAbsolute; | 1104 return EPosition::kAbsolute; |
1105 case CSSValueFixed: | 1105 case CSSValueFixed: |
1106 return EPosition::kFixed; | 1106 return EPosition::kFixed; |
1107 case CSSValueSticky: | 1107 case CSSValueSticky: |
1108 return EPosition::kSticky; | 1108 return EPosition::kSticky; |
1109 default: | 1109 default: |
1110 break; | 1110 break; |
1111 } | 1111 } |
1112 | 1112 |
1113 ASSERT_NOT_REACHED(); | 1113 NOTREACHED(); |
1114 return EPosition::kStatic; | 1114 return EPosition::kStatic; |
1115 } | 1115 } |
1116 | 1116 |
1117 template <> | 1117 template <> |
1118 inline CSSIdentifierValue::CSSIdentifierValue(EResize e) | 1118 inline CSSIdentifierValue::CSSIdentifierValue(EResize e) |
1119 : CSSValue(IdentifierClass) { | 1119 : CSSValue(IdentifierClass) { |
1120 switch (e) { | 1120 switch (e) { |
1121 case RESIZE_BOTH: | 1121 case RESIZE_BOTH: |
1122 m_valueID = CSSValueBoth; | 1122 m_valueID = CSSValueBoth; |
1123 break; | 1123 break; |
(...skipping 21 matching lines...) Expand all Loading... |
1145 case CSSValueAuto: | 1145 case CSSValueAuto: |
1146 // Depends on settings, thus should be handled by the caller. | 1146 // Depends on settings, thus should be handled by the caller. |
1147 NOTREACHED(); | 1147 NOTREACHED(); |
1148 return RESIZE_NONE; | 1148 return RESIZE_NONE; |
1149 case CSSValueNone: | 1149 case CSSValueNone: |
1150 return RESIZE_NONE; | 1150 return RESIZE_NONE; |
1151 default: | 1151 default: |
1152 break; | 1152 break; |
1153 } | 1153 } |
1154 | 1154 |
1155 ASSERT_NOT_REACHED(); | 1155 NOTREACHED(); |
1156 return RESIZE_NONE; | 1156 return RESIZE_NONE; |
1157 } | 1157 } |
1158 | 1158 |
1159 template <> | 1159 template <> |
1160 inline CSSIdentifierValue::CSSIdentifierValue(ETableLayout e) | 1160 inline CSSIdentifierValue::CSSIdentifierValue(ETableLayout e) |
1161 : CSSValue(IdentifierClass) { | 1161 : CSSValue(IdentifierClass) { |
1162 switch (e) { | 1162 switch (e) { |
1163 case ETableLayout::kAuto: | 1163 case ETableLayout::kAuto: |
1164 m_valueID = CSSValueAuto; | 1164 m_valueID = CSSValueAuto; |
1165 break; | 1165 break; |
1166 case ETableLayout::kFixed: | 1166 case ETableLayout::kFixed: |
1167 m_valueID = CSSValueFixed; | 1167 m_valueID = CSSValueFixed; |
1168 break; | 1168 break; |
1169 } | 1169 } |
1170 } | 1170 } |
1171 | 1171 |
1172 template <> | 1172 template <> |
1173 inline ETableLayout CSSIdentifierValue::convertTo() const { | 1173 inline ETableLayout CSSIdentifierValue::convertTo() const { |
1174 switch (m_valueID) { | 1174 switch (m_valueID) { |
1175 case CSSValueFixed: | 1175 case CSSValueFixed: |
1176 return ETableLayout::kFixed; | 1176 return ETableLayout::kFixed; |
1177 case CSSValueAuto: | 1177 case CSSValueAuto: |
1178 return ETableLayout::kAuto; | 1178 return ETableLayout::kAuto; |
1179 default: | 1179 default: |
1180 break; | 1180 break; |
1181 } | 1181 } |
1182 | 1182 |
1183 ASSERT_NOT_REACHED(); | 1183 NOTREACHED(); |
1184 return ETableLayout::kAuto; | 1184 return ETableLayout::kAuto; |
1185 } | 1185 } |
1186 | 1186 |
1187 template <> | 1187 template <> |
1188 inline CSSIdentifierValue::CSSIdentifierValue(TextAlignLast e) | 1188 inline CSSIdentifierValue::CSSIdentifierValue(TextAlignLast e) |
1189 : CSSValue(IdentifierClass) { | 1189 : CSSValue(IdentifierClass) { |
1190 switch (e) { | 1190 switch (e) { |
1191 case TextAlignLastStart: | 1191 case TextAlignLastStart: |
1192 m_valueID = CSSValueStart; | 1192 m_valueID = CSSValueStart; |
1193 break; | 1193 break; |
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1226 case CSSValueRight: | 1226 case CSSValueRight: |
1227 return TextAlignLastRight; | 1227 return TextAlignLastRight; |
1228 case CSSValueCenter: | 1228 case CSSValueCenter: |
1229 return TextAlignLastCenter; | 1229 return TextAlignLastCenter; |
1230 case CSSValueJustify: | 1230 case CSSValueJustify: |
1231 return TextAlignLastJustify; | 1231 return TextAlignLastJustify; |
1232 default: | 1232 default: |
1233 break; | 1233 break; |
1234 } | 1234 } |
1235 | 1235 |
1236 ASSERT_NOT_REACHED(); | 1236 NOTREACHED(); |
1237 return TextAlignLastAuto; | 1237 return TextAlignLastAuto; |
1238 } | 1238 } |
1239 | 1239 |
1240 template <> | 1240 template <> |
1241 inline CSSIdentifierValue::CSSIdentifierValue(TextJustify e) | 1241 inline CSSIdentifierValue::CSSIdentifierValue(TextJustify e) |
1242 : CSSValue(IdentifierClass) { | 1242 : CSSValue(IdentifierClass) { |
1243 switch (e) { | 1243 switch (e) { |
1244 case TextJustifyAuto: | 1244 case TextJustifyAuto: |
1245 m_valueID = CSSValueAuto; | 1245 m_valueID = CSSValueAuto; |
1246 break; | 1246 break; |
(...skipping 17 matching lines...) Expand all Loading... |
1264 case CSSValueNone: | 1264 case CSSValueNone: |
1265 return TextJustifyNone; | 1265 return TextJustifyNone; |
1266 case CSSValueInterWord: | 1266 case CSSValueInterWord: |
1267 return TextJustifyInterWord; | 1267 return TextJustifyInterWord; |
1268 case CSSValueDistribute: | 1268 case CSSValueDistribute: |
1269 return TextJustifyDistribute; | 1269 return TextJustifyDistribute; |
1270 default: | 1270 default: |
1271 break; | 1271 break; |
1272 } | 1272 } |
1273 | 1273 |
1274 ASSERT_NOT_REACHED(); | 1274 NOTREACHED(); |
1275 return TextJustifyAuto; | 1275 return TextJustifyAuto; |
1276 } | 1276 } |
1277 | 1277 |
1278 template <> | 1278 template <> |
1279 inline TextDecoration CSSIdentifierValue::convertTo() const { | 1279 inline TextDecoration CSSIdentifierValue::convertTo() const { |
1280 switch (m_valueID) { | 1280 switch (m_valueID) { |
1281 case CSSValueNone: | 1281 case CSSValueNone: |
1282 return TextDecorationNone; | 1282 return TextDecorationNone; |
1283 case CSSValueUnderline: | 1283 case CSSValueUnderline: |
1284 return TextDecorationUnderline; | 1284 return TextDecorationUnderline; |
1285 case CSSValueOverline: | 1285 case CSSValueOverline: |
1286 return TextDecorationOverline; | 1286 return TextDecorationOverline; |
1287 case CSSValueLineThrough: | 1287 case CSSValueLineThrough: |
1288 return TextDecorationLineThrough; | 1288 return TextDecorationLineThrough; |
1289 case CSSValueBlink: | 1289 case CSSValueBlink: |
1290 return TextDecorationBlink; | 1290 return TextDecorationBlink; |
1291 default: | 1291 default: |
1292 break; | 1292 break; |
1293 } | 1293 } |
1294 | 1294 |
1295 ASSERT_NOT_REACHED(); | 1295 NOTREACHED(); |
1296 return TextDecorationNone; | 1296 return TextDecorationNone; |
1297 } | 1297 } |
1298 | 1298 |
1299 template <> | 1299 template <> |
1300 inline TextDecorationStyle CSSIdentifierValue::convertTo() const { | 1300 inline TextDecorationStyle CSSIdentifierValue::convertTo() const { |
1301 switch (m_valueID) { | 1301 switch (m_valueID) { |
1302 case CSSValueSolid: | 1302 case CSSValueSolid: |
1303 return TextDecorationStyleSolid; | 1303 return TextDecorationStyleSolid; |
1304 case CSSValueDouble: | 1304 case CSSValueDouble: |
1305 return TextDecorationStyleDouble; | 1305 return TextDecorationStyleDouble; |
1306 case CSSValueDotted: | 1306 case CSSValueDotted: |
1307 return TextDecorationStyleDotted; | 1307 return TextDecorationStyleDotted; |
1308 case CSSValueDashed: | 1308 case CSSValueDashed: |
1309 return TextDecorationStyleDashed; | 1309 return TextDecorationStyleDashed; |
1310 case CSSValueWavy: | 1310 case CSSValueWavy: |
1311 return TextDecorationStyleWavy; | 1311 return TextDecorationStyleWavy; |
1312 default: | 1312 default: |
1313 break; | 1313 break; |
1314 } | 1314 } |
1315 | 1315 |
1316 ASSERT_NOT_REACHED(); | 1316 NOTREACHED(); |
1317 return TextDecorationStyleSolid; | 1317 return TextDecorationStyleSolid; |
1318 } | 1318 } |
1319 | 1319 |
1320 template <> | 1320 template <> |
1321 inline CSSIdentifierValue::CSSIdentifierValue(TextUnderlinePosition e) | 1321 inline CSSIdentifierValue::CSSIdentifierValue(TextUnderlinePosition e) |
1322 : CSSValue(IdentifierClass) { | 1322 : CSSValue(IdentifierClass) { |
1323 switch (e) { | 1323 switch (e) { |
1324 case TextUnderlinePositionAuto: | 1324 case TextUnderlinePositionAuto: |
1325 m_valueID = CSSValueAuto; | 1325 m_valueID = CSSValueAuto; |
1326 break; | 1326 break; |
(...skipping 11 matching lines...) Expand all Loading... |
1338 case CSSValueAuto: | 1338 case CSSValueAuto: |
1339 return TextUnderlinePositionAuto; | 1339 return TextUnderlinePositionAuto; |
1340 case CSSValueUnder: | 1340 case CSSValueUnder: |
1341 return TextUnderlinePositionUnder; | 1341 return TextUnderlinePositionUnder; |
1342 default: | 1342 default: |
1343 break; | 1343 break; |
1344 } | 1344 } |
1345 | 1345 |
1346 // FIXME: Implement support for 'under left' and 'under right' values. | 1346 // FIXME: Implement support for 'under left' and 'under right' values. |
1347 | 1347 |
1348 ASSERT_NOT_REACHED(); | 1348 NOTREACHED(); |
1349 return TextUnderlinePositionAuto; | 1349 return TextUnderlinePositionAuto; |
1350 } | 1350 } |
1351 | 1351 |
1352 template <> | 1352 template <> |
1353 inline TextDecorationSkip CSSIdentifierValue::convertTo() const { | 1353 inline TextDecorationSkip CSSIdentifierValue::convertTo() const { |
1354 switch (m_valueID) { | 1354 switch (m_valueID) { |
1355 case CSSValueObjects: | 1355 case CSSValueObjects: |
1356 return TextDecorationSkipObjects; | 1356 return TextDecorationSkipObjects; |
1357 case CSSValueInk: | 1357 case CSSValueInk: |
1358 return TextDecorationSkipInk; | 1358 return TextDecorationSkipInk; |
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1391 case CSSValueDisc: | 1391 case CSSValueDisc: |
1392 return TSDISC; | 1392 return TSDISC; |
1393 case CSSValueCircle: | 1393 case CSSValueCircle: |
1394 return TSCIRCLE; | 1394 return TSCIRCLE; |
1395 case CSSValueSquare: | 1395 case CSSValueSquare: |
1396 return TSSQUARE; | 1396 return TSSQUARE; |
1397 default: | 1397 default: |
1398 break; | 1398 break; |
1399 } | 1399 } |
1400 | 1400 |
1401 ASSERT_NOT_REACHED(); | 1401 NOTREACHED(); |
1402 return TSNONE; | 1402 return TSNONE; |
1403 } | 1403 } |
1404 | 1404 |
1405 template <> | 1405 template <> |
1406 inline CSSIdentifierValue::CSSIdentifierValue(EUserDrag e) | 1406 inline CSSIdentifierValue::CSSIdentifierValue(EUserDrag e) |
1407 : CSSValue(IdentifierClass) { | 1407 : CSSValue(IdentifierClass) { |
1408 switch (e) { | 1408 switch (e) { |
1409 case DRAG_AUTO: | 1409 case DRAG_AUTO: |
1410 m_valueID = CSSValueAuto; | 1410 m_valueID = CSSValueAuto; |
1411 break; | 1411 break; |
(...skipping 14 matching lines...) Expand all Loading... |
1426 case CSSValueAuto: | 1426 case CSSValueAuto: |
1427 return DRAG_AUTO; | 1427 return DRAG_AUTO; |
1428 case CSSValueNone: | 1428 case CSSValueNone: |
1429 return DRAG_NONE; | 1429 return DRAG_NONE; |
1430 case CSSValueElement: | 1430 case CSSValueElement: |
1431 return DRAG_ELEMENT; | 1431 return DRAG_ELEMENT; |
1432 default: | 1432 default: |
1433 break; | 1433 break; |
1434 } | 1434 } |
1435 | 1435 |
1436 ASSERT_NOT_REACHED(); | 1436 NOTREACHED(); |
1437 return DRAG_AUTO; | 1437 return DRAG_AUTO; |
1438 } | 1438 } |
1439 | 1439 |
1440 template <> | 1440 template <> |
1441 inline CSSIdentifierValue::CSSIdentifierValue(EUserModify e) | 1441 inline CSSIdentifierValue::CSSIdentifierValue(EUserModify e) |
1442 : CSSValue(IdentifierClass) { | 1442 : CSSValue(IdentifierClass) { |
1443 switch (e) { | 1443 switch (e) { |
1444 case READ_ONLY: | 1444 case READ_ONLY: |
1445 m_valueID = CSSValueReadOnly; | 1445 m_valueID = CSSValueReadOnly; |
1446 break; | 1446 break; |
(...skipping 12 matching lines...) Expand all Loading... |
1459 case CSSValueReadOnly: | 1459 case CSSValueReadOnly: |
1460 return READ_ONLY; | 1460 return READ_ONLY; |
1461 case CSSValueReadWrite: | 1461 case CSSValueReadWrite: |
1462 return READ_WRITE; | 1462 return READ_WRITE; |
1463 case CSSValueReadWritePlaintextOnly: | 1463 case CSSValueReadWritePlaintextOnly: |
1464 return READ_WRITE_PLAINTEXT_ONLY; | 1464 return READ_WRITE_PLAINTEXT_ONLY; |
1465 default: | 1465 default: |
1466 break; | 1466 break; |
1467 } | 1467 } |
1468 | 1468 |
1469 ASSERT_NOT_REACHED(); | 1469 NOTREACHED(); |
1470 return READ_ONLY; | 1470 return READ_ONLY; |
1471 } | 1471 } |
1472 | 1472 |
1473 template <> | 1473 template <> |
1474 inline CSSIdentifierValue::CSSIdentifierValue(EUserSelect e) | 1474 inline CSSIdentifierValue::CSSIdentifierValue(EUserSelect e) |
1475 : CSSValue(IdentifierClass) { | 1475 : CSSValue(IdentifierClass) { |
1476 switch (e) { | 1476 switch (e) { |
1477 case SELECT_NONE: | 1477 case SELECT_NONE: |
1478 m_valueID = CSSValueNone; | 1478 m_valueID = CSSValueNone; |
1479 break; | 1479 break; |
(...skipping 14 matching lines...) Expand all Loading... |
1494 case CSSValueNone: | 1494 case CSSValueNone: |
1495 return SELECT_NONE; | 1495 return SELECT_NONE; |
1496 case CSSValueText: | 1496 case CSSValueText: |
1497 return SELECT_TEXT; | 1497 return SELECT_TEXT; |
1498 case CSSValueAll: | 1498 case CSSValueAll: |
1499 return SELECT_ALL; | 1499 return SELECT_ALL; |
1500 default: | 1500 default: |
1501 break; | 1501 break; |
1502 } | 1502 } |
1503 | 1503 |
1504 ASSERT_NOT_REACHED(); | 1504 NOTREACHED(); |
1505 return SELECT_TEXT; | 1505 return SELECT_TEXT; |
1506 } | 1506 } |
1507 | 1507 |
1508 template <> | 1508 template <> |
1509 inline CSSIdentifierValue::CSSIdentifierValue(EVerticalAlign a) | 1509 inline CSSIdentifierValue::CSSIdentifierValue(EVerticalAlign a) |
1510 : CSSValue(IdentifierClass) { | 1510 : CSSValue(IdentifierClass) { |
1511 switch (a) { | 1511 switch (a) { |
1512 case EVerticalAlign::kTop: | 1512 case EVerticalAlign::kTop: |
1513 m_valueID = CSSValueTop; | 1513 m_valueID = CSSValueTop; |
1514 break; | 1514 break; |
(...skipping 44 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1559 case CSSValueSub: | 1559 case CSSValueSub: |
1560 return EVerticalAlign::kSub; | 1560 return EVerticalAlign::kSub; |
1561 case CSSValueSuper: | 1561 case CSSValueSuper: |
1562 return EVerticalAlign::kSuper; | 1562 return EVerticalAlign::kSuper; |
1563 case CSSValueWebkitBaselineMiddle: | 1563 case CSSValueWebkitBaselineMiddle: |
1564 return EVerticalAlign::kBaselineMiddle; | 1564 return EVerticalAlign::kBaselineMiddle; |
1565 default: | 1565 default: |
1566 break; | 1566 break; |
1567 } | 1567 } |
1568 | 1568 |
1569 ASSERT_NOT_REACHED(); | 1569 NOTREACHED(); |
1570 return EVerticalAlign::kTop; | 1570 return EVerticalAlign::kTop; |
1571 } | 1571 } |
1572 | 1572 |
1573 template <> | 1573 template <> |
1574 inline CSSIdentifierValue::CSSIdentifierValue(EWordBreak e) | 1574 inline CSSIdentifierValue::CSSIdentifierValue(EWordBreak e) |
1575 : CSSValue(IdentifierClass) { | 1575 : CSSValue(IdentifierClass) { |
1576 switch (e) { | 1576 switch (e) { |
1577 case NormalWordBreak: | 1577 case NormalWordBreak: |
1578 m_valueID = CSSValueNormal; | 1578 m_valueID = CSSValueNormal; |
1579 break; | 1579 break; |
(...skipping 17 matching lines...) Expand all Loading... |
1597 case CSSValueBreakWord: | 1597 case CSSValueBreakWord: |
1598 return BreakWordBreak; | 1598 return BreakWordBreak; |
1599 case CSSValueNormal: | 1599 case CSSValueNormal: |
1600 return NormalWordBreak; | 1600 return NormalWordBreak; |
1601 case CSSValueKeepAll: | 1601 case CSSValueKeepAll: |
1602 return KeepAllWordBreak; | 1602 return KeepAllWordBreak; |
1603 default: | 1603 default: |
1604 break; | 1604 break; |
1605 } | 1605 } |
1606 | 1606 |
1607 ASSERT_NOT_REACHED(); | 1607 NOTREACHED(); |
1608 return NormalWordBreak; | 1608 return NormalWordBreak; |
1609 } | 1609 } |
1610 | 1610 |
1611 template <> | 1611 template <> |
1612 inline CSSIdentifierValue::CSSIdentifierValue(EOverflowWrap e) | 1612 inline CSSIdentifierValue::CSSIdentifierValue(EOverflowWrap e) |
1613 : CSSValue(IdentifierClass) { | 1613 : CSSValue(IdentifierClass) { |
1614 switch (e) { | 1614 switch (e) { |
1615 case NormalOverflowWrap: | 1615 case NormalOverflowWrap: |
1616 m_valueID = CSSValueNormal; | 1616 m_valueID = CSSValueNormal; |
1617 break; | 1617 break; |
1618 case BreakOverflowWrap: | 1618 case BreakOverflowWrap: |
1619 m_valueID = CSSValueBreakWord; | 1619 m_valueID = CSSValueBreakWord; |
1620 break; | 1620 break; |
1621 } | 1621 } |
1622 } | 1622 } |
1623 | 1623 |
1624 template <> | 1624 template <> |
1625 inline EOverflowWrap CSSIdentifierValue::convertTo() const { | 1625 inline EOverflowWrap CSSIdentifierValue::convertTo() const { |
1626 switch (m_valueID) { | 1626 switch (m_valueID) { |
1627 case CSSValueBreakWord: | 1627 case CSSValueBreakWord: |
1628 return BreakOverflowWrap; | 1628 return BreakOverflowWrap; |
1629 case CSSValueNormal: | 1629 case CSSValueNormal: |
1630 return NormalOverflowWrap; | 1630 return NormalOverflowWrap; |
1631 default: | 1631 default: |
1632 break; | 1632 break; |
1633 } | 1633 } |
1634 | 1634 |
1635 ASSERT_NOT_REACHED(); | 1635 NOTREACHED(); |
1636 return NormalOverflowWrap; | 1636 return NormalOverflowWrap; |
1637 } | 1637 } |
1638 | 1638 |
1639 template <> | 1639 template <> |
1640 inline CSSIdentifierValue::CSSIdentifierValue(TextCombine e) | 1640 inline CSSIdentifierValue::CSSIdentifierValue(TextCombine e) |
1641 : CSSValue(IdentifierClass) { | 1641 : CSSValue(IdentifierClass) { |
1642 switch (e) { | 1642 switch (e) { |
1643 case TextCombineNone: | 1643 case TextCombineNone: |
1644 m_valueID = CSSValueNone; | 1644 m_valueID = CSSValueNone; |
1645 break; | 1645 break; |
1646 case TextCombineAll: | 1646 case TextCombineAll: |
1647 m_valueID = CSSValueAll; | 1647 m_valueID = CSSValueAll; |
1648 break; | 1648 break; |
1649 } | 1649 } |
1650 } | 1650 } |
1651 | 1651 |
1652 template <> | 1652 template <> |
1653 inline TextCombine CSSIdentifierValue::convertTo() const { | 1653 inline TextCombine CSSIdentifierValue::convertTo() const { |
1654 switch (m_valueID) { | 1654 switch (m_valueID) { |
1655 case CSSValueNone: | 1655 case CSSValueNone: |
1656 return TextCombineNone; | 1656 return TextCombineNone; |
1657 case CSSValueAll: | 1657 case CSSValueAll: |
1658 case CSSValueHorizontal: // -webkit-text-combine | 1658 case CSSValueHorizontal: // -webkit-text-combine |
1659 return TextCombineAll; | 1659 return TextCombineAll; |
1660 default: | 1660 default: |
1661 break; | 1661 break; |
1662 } | 1662 } |
1663 | 1663 |
1664 ASSERT_NOT_REACHED(); | 1664 NOTREACHED(); |
1665 return TextCombineNone; | 1665 return TextCombineNone; |
1666 } | 1666 } |
1667 | 1667 |
1668 template <> | 1668 template <> |
1669 inline CSSIdentifierValue::CSSIdentifierValue(RubyPosition position) | 1669 inline CSSIdentifierValue::CSSIdentifierValue(RubyPosition position) |
1670 : CSSValue(IdentifierClass) { | 1670 : CSSValue(IdentifierClass) { |
1671 switch (position) { | 1671 switch (position) { |
1672 case RubyPositionBefore: | 1672 case RubyPositionBefore: |
1673 m_valueID = CSSValueBefore; | 1673 m_valueID = CSSValueBefore; |
1674 break; | 1674 break; |
1675 case RubyPositionAfter: | 1675 case RubyPositionAfter: |
1676 m_valueID = CSSValueAfter; | 1676 m_valueID = CSSValueAfter; |
1677 break; | 1677 break; |
1678 } | 1678 } |
1679 } | 1679 } |
1680 | 1680 |
1681 template <> | 1681 template <> |
1682 inline RubyPosition CSSIdentifierValue::convertTo() const { | 1682 inline RubyPosition CSSIdentifierValue::convertTo() const { |
1683 switch (m_valueID) { | 1683 switch (m_valueID) { |
1684 case CSSValueBefore: | 1684 case CSSValueBefore: |
1685 return RubyPositionBefore; | 1685 return RubyPositionBefore; |
1686 case CSSValueAfter: | 1686 case CSSValueAfter: |
1687 return RubyPositionAfter; | 1687 return RubyPositionAfter; |
1688 default: | 1688 default: |
1689 break; | 1689 break; |
1690 } | 1690 } |
1691 | 1691 |
1692 ASSERT_NOT_REACHED(); | 1692 NOTREACHED(); |
1693 return RubyPositionBefore; | 1693 return RubyPositionBefore; |
1694 } | 1694 } |
1695 | 1695 |
1696 template <> | 1696 template <> |
1697 inline CSSIdentifierValue::CSSIdentifierValue(TextEmphasisPosition position) | 1697 inline CSSIdentifierValue::CSSIdentifierValue(TextEmphasisPosition position) |
1698 : CSSValue(IdentifierClass) { | 1698 : CSSValue(IdentifierClass) { |
1699 switch (position) { | 1699 switch (position) { |
1700 case TextEmphasisPositionOver: | 1700 case TextEmphasisPositionOver: |
1701 m_valueID = CSSValueOver; | 1701 m_valueID = CSSValueOver; |
1702 break; | 1702 break; |
1703 case TextEmphasisPositionUnder: | 1703 case TextEmphasisPositionUnder: |
1704 m_valueID = CSSValueUnder; | 1704 m_valueID = CSSValueUnder; |
1705 break; | 1705 break; |
1706 } | 1706 } |
1707 } | 1707 } |
1708 | 1708 |
1709 template <> | 1709 template <> |
1710 inline TextEmphasisPosition CSSIdentifierValue::convertTo() const { | 1710 inline TextEmphasisPosition CSSIdentifierValue::convertTo() const { |
1711 switch (m_valueID) { | 1711 switch (m_valueID) { |
1712 case CSSValueOver: | 1712 case CSSValueOver: |
1713 return TextEmphasisPositionOver; | 1713 return TextEmphasisPositionOver; |
1714 case CSSValueUnder: | 1714 case CSSValueUnder: |
1715 return TextEmphasisPositionUnder; | 1715 return TextEmphasisPositionUnder; |
1716 default: | 1716 default: |
1717 break; | 1717 break; |
1718 } | 1718 } |
1719 | 1719 |
1720 ASSERT_NOT_REACHED(); | 1720 NOTREACHED(); |
1721 return TextEmphasisPositionOver; | 1721 return TextEmphasisPositionOver; |
1722 } | 1722 } |
1723 | 1723 |
1724 template <> | 1724 template <> |
1725 inline CSSIdentifierValue::CSSIdentifierValue(TextOverflow overflow) | 1725 inline CSSIdentifierValue::CSSIdentifierValue(TextOverflow overflow) |
1726 : CSSValue(IdentifierClass) { | 1726 : CSSValue(IdentifierClass) { |
1727 switch (overflow) { | 1727 switch (overflow) { |
1728 case TextOverflowClip: | 1728 case TextOverflowClip: |
1729 m_valueID = CSSValueClip; | 1729 m_valueID = CSSValueClip; |
1730 break; | 1730 break; |
1731 case TextOverflowEllipsis: | 1731 case TextOverflowEllipsis: |
1732 m_valueID = CSSValueEllipsis; | 1732 m_valueID = CSSValueEllipsis; |
1733 break; | 1733 break; |
1734 } | 1734 } |
1735 } | 1735 } |
1736 | 1736 |
1737 template <> | 1737 template <> |
1738 inline TextOverflow CSSIdentifierValue::convertTo() const { | 1738 inline TextOverflow CSSIdentifierValue::convertTo() const { |
1739 switch (m_valueID) { | 1739 switch (m_valueID) { |
1740 case CSSValueClip: | 1740 case CSSValueClip: |
1741 return TextOverflowClip; | 1741 return TextOverflowClip; |
1742 case CSSValueEllipsis: | 1742 case CSSValueEllipsis: |
1743 return TextOverflowEllipsis; | 1743 return TextOverflowEllipsis; |
1744 default: | 1744 default: |
1745 break; | 1745 break; |
1746 } | 1746 } |
1747 | 1747 |
1748 ASSERT_NOT_REACHED(); | 1748 NOTREACHED(); |
1749 return TextOverflowClip; | 1749 return TextOverflowClip; |
1750 } | 1750 } |
1751 | 1751 |
1752 template <> | 1752 template <> |
1753 inline CSSIdentifierValue::CSSIdentifierValue(TextEmphasisFill fill) | 1753 inline CSSIdentifierValue::CSSIdentifierValue(TextEmphasisFill fill) |
1754 : CSSValue(IdentifierClass) { | 1754 : CSSValue(IdentifierClass) { |
1755 switch (fill) { | 1755 switch (fill) { |
1756 case TextEmphasisFillFilled: | 1756 case TextEmphasisFillFilled: |
1757 m_valueID = CSSValueFilled; | 1757 m_valueID = CSSValueFilled; |
1758 break; | 1758 break; |
1759 case TextEmphasisFillOpen: | 1759 case TextEmphasisFillOpen: |
1760 m_valueID = CSSValueOpen; | 1760 m_valueID = CSSValueOpen; |
1761 break; | 1761 break; |
1762 } | 1762 } |
1763 } | 1763 } |
1764 | 1764 |
1765 template <> | 1765 template <> |
1766 inline TextEmphasisFill CSSIdentifierValue::convertTo() const { | 1766 inline TextEmphasisFill CSSIdentifierValue::convertTo() const { |
1767 switch (m_valueID) { | 1767 switch (m_valueID) { |
1768 case CSSValueFilled: | 1768 case CSSValueFilled: |
1769 return TextEmphasisFillFilled; | 1769 return TextEmphasisFillFilled; |
1770 case CSSValueOpen: | 1770 case CSSValueOpen: |
1771 return TextEmphasisFillOpen; | 1771 return TextEmphasisFillOpen; |
1772 default: | 1772 default: |
1773 break; | 1773 break; |
1774 } | 1774 } |
1775 | 1775 |
1776 ASSERT_NOT_REACHED(); | 1776 NOTREACHED(); |
1777 return TextEmphasisFillFilled; | 1777 return TextEmphasisFillFilled; |
1778 } | 1778 } |
1779 | 1779 |
1780 template <> | 1780 template <> |
1781 inline CSSIdentifierValue::CSSIdentifierValue(TextEmphasisMark mark) | 1781 inline CSSIdentifierValue::CSSIdentifierValue(TextEmphasisMark mark) |
1782 : CSSValue(IdentifierClass) { | 1782 : CSSValue(IdentifierClass) { |
1783 switch (mark) { | 1783 switch (mark) { |
1784 case TextEmphasisMarkDot: | 1784 case TextEmphasisMarkDot: |
1785 m_valueID = CSSValueDot; | 1785 m_valueID = CSSValueDot; |
1786 break; | 1786 break; |
1787 case TextEmphasisMarkCircle: | 1787 case TextEmphasisMarkCircle: |
1788 m_valueID = CSSValueCircle; | 1788 m_valueID = CSSValueCircle; |
1789 break; | 1789 break; |
1790 case TextEmphasisMarkDoubleCircle: | 1790 case TextEmphasisMarkDoubleCircle: |
1791 m_valueID = CSSValueDoubleCircle; | 1791 m_valueID = CSSValueDoubleCircle; |
1792 break; | 1792 break; |
1793 case TextEmphasisMarkTriangle: | 1793 case TextEmphasisMarkTriangle: |
1794 m_valueID = CSSValueTriangle; | 1794 m_valueID = CSSValueTriangle; |
1795 break; | 1795 break; |
1796 case TextEmphasisMarkSesame: | 1796 case TextEmphasisMarkSesame: |
1797 m_valueID = CSSValueSesame; | 1797 m_valueID = CSSValueSesame; |
1798 break; | 1798 break; |
1799 case TextEmphasisMarkNone: | 1799 case TextEmphasisMarkNone: |
1800 case TextEmphasisMarkAuto: | 1800 case TextEmphasisMarkAuto: |
1801 case TextEmphasisMarkCustom: | 1801 case TextEmphasisMarkCustom: |
1802 ASSERT_NOT_REACHED(); | 1802 NOTREACHED(); |
1803 m_valueID = CSSValueNone; | 1803 m_valueID = CSSValueNone; |
1804 break; | 1804 break; |
1805 } | 1805 } |
1806 } | 1806 } |
1807 | 1807 |
1808 template <> | 1808 template <> |
1809 inline TextEmphasisMark CSSIdentifierValue::convertTo() const { | 1809 inline TextEmphasisMark CSSIdentifierValue::convertTo() const { |
1810 switch (m_valueID) { | 1810 switch (m_valueID) { |
1811 case CSSValueNone: | 1811 case CSSValueNone: |
1812 return TextEmphasisMarkNone; | 1812 return TextEmphasisMarkNone; |
1813 case CSSValueDot: | 1813 case CSSValueDot: |
1814 return TextEmphasisMarkDot; | 1814 return TextEmphasisMarkDot; |
1815 case CSSValueCircle: | 1815 case CSSValueCircle: |
1816 return TextEmphasisMarkCircle; | 1816 return TextEmphasisMarkCircle; |
1817 case CSSValueDoubleCircle: | 1817 case CSSValueDoubleCircle: |
1818 return TextEmphasisMarkDoubleCircle; | 1818 return TextEmphasisMarkDoubleCircle; |
1819 case CSSValueTriangle: | 1819 case CSSValueTriangle: |
1820 return TextEmphasisMarkTriangle; | 1820 return TextEmphasisMarkTriangle; |
1821 case CSSValueSesame: | 1821 case CSSValueSesame: |
1822 return TextEmphasisMarkSesame; | 1822 return TextEmphasisMarkSesame; |
1823 default: | 1823 default: |
1824 break; | 1824 break; |
1825 } | 1825 } |
1826 | 1826 |
1827 ASSERT_NOT_REACHED(); | 1827 NOTREACHED(); |
1828 return TextEmphasisMarkNone; | 1828 return TextEmphasisMarkNone; |
1829 } | 1829 } |
1830 | 1830 |
1831 template <> | 1831 template <> |
1832 inline CSSIdentifierValue::CSSIdentifierValue(TextOrientation e) | 1832 inline CSSIdentifierValue::CSSIdentifierValue(TextOrientation e) |
1833 : CSSValue(IdentifierClass) { | 1833 : CSSValue(IdentifierClass) { |
1834 switch (e) { | 1834 switch (e) { |
1835 case TextOrientationSideways: | 1835 case TextOrientationSideways: |
1836 m_valueID = CSSValueSideways; | 1836 m_valueID = CSSValueSideways; |
1837 break; | 1837 break; |
(...skipping 14 matching lines...) Expand all Loading... |
1852 return TextOrientationSideways; | 1852 return TextOrientationSideways; |
1853 case CSSValueMixed: | 1853 case CSSValueMixed: |
1854 case CSSValueVerticalRight: // -webkit-text-orientation | 1854 case CSSValueVerticalRight: // -webkit-text-orientation |
1855 return TextOrientationMixed; | 1855 return TextOrientationMixed; |
1856 case CSSValueUpright: | 1856 case CSSValueUpright: |
1857 return TextOrientationUpright; | 1857 return TextOrientationUpright; |
1858 default: | 1858 default: |
1859 break; | 1859 break; |
1860 } | 1860 } |
1861 | 1861 |
1862 ASSERT_NOT_REACHED(); | 1862 NOTREACHED(); |
1863 return TextOrientationMixed; | 1863 return TextOrientationMixed; |
1864 } | 1864 } |
1865 | 1865 |
1866 template <> | 1866 template <> |
1867 inline CSSIdentifierValue::CSSIdentifierValue(FontDescription::Kerning kerning) | 1867 inline CSSIdentifierValue::CSSIdentifierValue(FontDescription::Kerning kerning) |
1868 : CSSValue(IdentifierClass) { | 1868 : CSSValue(IdentifierClass) { |
1869 switch (kerning) { | 1869 switch (kerning) { |
1870 case FontDescription::AutoKerning: | 1870 case FontDescription::AutoKerning: |
1871 m_valueID = CSSValueAuto; | 1871 m_valueID = CSSValueAuto; |
1872 return; | 1872 return; |
1873 case FontDescription::NormalKerning: | 1873 case FontDescription::NormalKerning: |
1874 m_valueID = CSSValueNormal; | 1874 m_valueID = CSSValueNormal; |
1875 return; | 1875 return; |
1876 case FontDescription::NoneKerning: | 1876 case FontDescription::NoneKerning: |
1877 m_valueID = CSSValueNone; | 1877 m_valueID = CSSValueNone; |
1878 return; | 1878 return; |
1879 } | 1879 } |
1880 | 1880 |
1881 ASSERT_NOT_REACHED(); | 1881 NOTREACHED(); |
1882 m_valueID = CSSValueAuto; | 1882 m_valueID = CSSValueAuto; |
1883 } | 1883 } |
1884 | 1884 |
1885 template <> | 1885 template <> |
1886 inline FontDescription::Kerning CSSIdentifierValue::convertTo() const { | 1886 inline FontDescription::Kerning CSSIdentifierValue::convertTo() const { |
1887 switch (m_valueID) { | 1887 switch (m_valueID) { |
1888 case CSSValueAuto: | 1888 case CSSValueAuto: |
1889 return FontDescription::AutoKerning; | 1889 return FontDescription::AutoKerning; |
1890 case CSSValueNormal: | 1890 case CSSValueNormal: |
1891 return FontDescription::NormalKerning; | 1891 return FontDescription::NormalKerning; |
1892 case CSSValueNone: | 1892 case CSSValueNone: |
1893 return FontDescription::NoneKerning; | 1893 return FontDescription::NoneKerning; |
1894 default: | 1894 default: |
1895 break; | 1895 break; |
1896 } | 1896 } |
1897 | 1897 |
1898 ASSERT_NOT_REACHED(); | 1898 NOTREACHED(); |
1899 return FontDescription::AutoKerning; | 1899 return FontDescription::AutoKerning; |
1900 } | 1900 } |
1901 | 1901 |
1902 template <> | 1902 template <> |
1903 inline CSSIdentifierValue::CSSIdentifierValue(ObjectFit fit) | 1903 inline CSSIdentifierValue::CSSIdentifierValue(ObjectFit fit) |
1904 : CSSValue(IdentifierClass) { | 1904 : CSSValue(IdentifierClass) { |
1905 switch (fit) { | 1905 switch (fit) { |
1906 case ObjectFitFill: | 1906 case ObjectFitFill: |
1907 m_valueID = CSSValueFill; | 1907 m_valueID = CSSValueFill; |
1908 break; | 1908 break; |
(...skipping 19 matching lines...) Expand all Loading... |
1928 return ObjectFitFill; | 1928 return ObjectFitFill; |
1929 case CSSValueContain: | 1929 case CSSValueContain: |
1930 return ObjectFitContain; | 1930 return ObjectFitContain; |
1931 case CSSValueCover: | 1931 case CSSValueCover: |
1932 return ObjectFitCover; | 1932 return ObjectFitCover; |
1933 case CSSValueNone: | 1933 case CSSValueNone: |
1934 return ObjectFitNone; | 1934 return ObjectFitNone; |
1935 case CSSValueScaleDown: | 1935 case CSSValueScaleDown: |
1936 return ObjectFitScaleDown; | 1936 return ObjectFitScaleDown; |
1937 default: | 1937 default: |
1938 ASSERT_NOT_REACHED(); | 1938 NOTREACHED(); |
1939 return ObjectFitFill; | 1939 return ObjectFitFill; |
1940 } | 1940 } |
1941 } | 1941 } |
1942 | 1942 |
1943 template <> | 1943 template <> |
1944 inline CSSIdentifierValue::CSSIdentifierValue(EFillSizeType fillSize) | 1944 inline CSSIdentifierValue::CSSIdentifierValue(EFillSizeType fillSize) |
1945 : CSSValue(IdentifierClass) { | 1945 : CSSValue(IdentifierClass) { |
1946 switch (fillSize) { | 1946 switch (fillSize) { |
1947 case Contain: | 1947 case Contain: |
1948 m_valueID = CSSValueContain; | 1948 m_valueID = CSSValueContain; |
1949 break; | 1949 break; |
1950 case Cover: | 1950 case Cover: |
1951 m_valueID = CSSValueCover; | 1951 m_valueID = CSSValueCover; |
1952 break; | 1952 break; |
1953 case SizeNone: | 1953 case SizeNone: |
1954 m_valueID = CSSValueNone; | 1954 m_valueID = CSSValueNone; |
1955 break; | 1955 break; |
1956 case SizeLength: | 1956 case SizeLength: |
1957 default: | 1957 default: |
1958 ASSERT_NOT_REACHED(); | 1958 NOTREACHED(); |
1959 } | 1959 } |
1960 } | 1960 } |
1961 | 1961 |
1962 template <> | 1962 template <> |
1963 inline CSSIdentifierValue::CSSIdentifierValue(FontSmoothingMode smoothing) | 1963 inline CSSIdentifierValue::CSSIdentifierValue(FontSmoothingMode smoothing) |
1964 : CSSValue(IdentifierClass) { | 1964 : CSSValue(IdentifierClass) { |
1965 switch (smoothing) { | 1965 switch (smoothing) { |
1966 case AutoSmoothing: | 1966 case AutoSmoothing: |
1967 m_valueID = CSSValueAuto; | 1967 m_valueID = CSSValueAuto; |
1968 return; | 1968 return; |
1969 case NoSmoothing: | 1969 case NoSmoothing: |
1970 m_valueID = CSSValueNone; | 1970 m_valueID = CSSValueNone; |
1971 return; | 1971 return; |
1972 case Antialiased: | 1972 case Antialiased: |
1973 m_valueID = CSSValueAntialiased; | 1973 m_valueID = CSSValueAntialiased; |
1974 return; | 1974 return; |
1975 case SubpixelAntialiased: | 1975 case SubpixelAntialiased: |
1976 m_valueID = CSSValueSubpixelAntialiased; | 1976 m_valueID = CSSValueSubpixelAntialiased; |
1977 return; | 1977 return; |
1978 } | 1978 } |
1979 | 1979 |
1980 ASSERT_NOT_REACHED(); | 1980 NOTREACHED(); |
1981 m_valueID = CSSValueAuto; | 1981 m_valueID = CSSValueAuto; |
1982 } | 1982 } |
1983 | 1983 |
1984 template <> | 1984 template <> |
1985 inline FontSmoothingMode CSSIdentifierValue::convertTo() const { | 1985 inline FontSmoothingMode CSSIdentifierValue::convertTo() const { |
1986 switch (m_valueID) { | 1986 switch (m_valueID) { |
1987 case CSSValueAuto: | 1987 case CSSValueAuto: |
1988 return AutoSmoothing; | 1988 return AutoSmoothing; |
1989 case CSSValueNone: | 1989 case CSSValueNone: |
1990 return NoSmoothing; | 1990 return NoSmoothing; |
1991 case CSSValueAntialiased: | 1991 case CSSValueAntialiased: |
1992 return Antialiased; | 1992 return Antialiased; |
1993 case CSSValueSubpixelAntialiased: | 1993 case CSSValueSubpixelAntialiased: |
1994 return SubpixelAntialiased; | 1994 return SubpixelAntialiased; |
1995 default: | 1995 default: |
1996 break; | 1996 break; |
1997 } | 1997 } |
1998 | 1998 |
1999 ASSERT_NOT_REACHED(); | 1999 NOTREACHED(); |
2000 return AutoSmoothing; | 2000 return AutoSmoothing; |
2001 } | 2001 } |
2002 | 2002 |
2003 template <> | 2003 template <> |
2004 inline CSSIdentifierValue::CSSIdentifierValue(FontWeight weight) | 2004 inline CSSIdentifierValue::CSSIdentifierValue(FontWeight weight) |
2005 : CSSValue(IdentifierClass) { | 2005 : CSSValue(IdentifierClass) { |
2006 switch (weight) { | 2006 switch (weight) { |
2007 case FontWeight900: | 2007 case FontWeight900: |
2008 m_valueID = CSSValue900; | 2008 m_valueID = CSSValue900; |
2009 return; | 2009 return; |
(...skipping 16 matching lines...) Expand all Loading... |
2026 m_valueID = CSSValue300; | 2026 m_valueID = CSSValue300; |
2027 return; | 2027 return; |
2028 case FontWeight200: | 2028 case FontWeight200: |
2029 m_valueID = CSSValue200; | 2029 m_valueID = CSSValue200; |
2030 return; | 2030 return; |
2031 case FontWeight100: | 2031 case FontWeight100: |
2032 m_valueID = CSSValue100; | 2032 m_valueID = CSSValue100; |
2033 return; | 2033 return; |
2034 } | 2034 } |
2035 | 2035 |
2036 ASSERT_NOT_REACHED(); | 2036 NOTREACHED(); |
2037 m_valueID = CSSValueNormal; | 2037 m_valueID = CSSValueNormal; |
2038 } | 2038 } |
2039 | 2039 |
2040 template <> | 2040 template <> |
2041 inline FontWeight CSSIdentifierValue::convertTo() const { | 2041 inline FontWeight CSSIdentifierValue::convertTo() const { |
2042 switch (m_valueID) { | 2042 switch (m_valueID) { |
2043 case CSSValueBold: | 2043 case CSSValueBold: |
2044 return FontWeightBold; | 2044 return FontWeightBold; |
2045 case CSSValueNormal: | 2045 case CSSValueNormal: |
2046 return FontWeightNormal; | 2046 return FontWeightNormal; |
(...skipping 12 matching lines...) Expand all Loading... |
2059 case CSSValue300: | 2059 case CSSValue300: |
2060 return FontWeight300; | 2060 return FontWeight300; |
2061 case CSSValue200: | 2061 case CSSValue200: |
2062 return FontWeight200; | 2062 return FontWeight200; |
2063 case CSSValue100: | 2063 case CSSValue100: |
2064 return FontWeight100; | 2064 return FontWeight100; |
2065 default: | 2065 default: |
2066 break; | 2066 break; |
2067 } | 2067 } |
2068 | 2068 |
2069 ASSERT_NOT_REACHED(); | 2069 NOTREACHED(); |
2070 return FontWeightNormal; | 2070 return FontWeightNormal; |
2071 } | 2071 } |
2072 | 2072 |
2073 template <> | 2073 template <> |
2074 inline CSSIdentifierValue::CSSIdentifierValue(FontStyle italic) | 2074 inline CSSIdentifierValue::CSSIdentifierValue(FontStyle italic) |
2075 : CSSValue(IdentifierClass) { | 2075 : CSSValue(IdentifierClass) { |
2076 switch (italic) { | 2076 switch (italic) { |
2077 case FontStyleNormal: | 2077 case FontStyleNormal: |
2078 m_valueID = CSSValueNormal; | 2078 m_valueID = CSSValueNormal; |
2079 return; | 2079 return; |
2080 case FontStyleOblique: | 2080 case FontStyleOblique: |
2081 m_valueID = CSSValueOblique; | 2081 m_valueID = CSSValueOblique; |
2082 return; | 2082 return; |
2083 case FontStyleItalic: | 2083 case FontStyleItalic: |
2084 m_valueID = CSSValueItalic; | 2084 m_valueID = CSSValueItalic; |
2085 return; | 2085 return; |
2086 } | 2086 } |
2087 | 2087 |
2088 ASSERT_NOT_REACHED(); | 2088 NOTREACHED(); |
2089 m_valueID = CSSValueNormal; | 2089 m_valueID = CSSValueNormal; |
2090 } | 2090 } |
2091 | 2091 |
2092 template <> | 2092 template <> |
2093 inline FontStyle CSSIdentifierValue::convertTo() const { | 2093 inline FontStyle CSSIdentifierValue::convertTo() const { |
2094 switch (m_valueID) { | 2094 switch (m_valueID) { |
2095 case CSSValueOblique: | 2095 case CSSValueOblique: |
2096 return FontStyleOblique; | 2096 return FontStyleOblique; |
2097 case CSSValueItalic: | 2097 case CSSValueItalic: |
2098 return FontStyleItalic; | 2098 return FontStyleItalic; |
2099 case CSSValueNormal: | 2099 case CSSValueNormal: |
2100 return FontStyleNormal; | 2100 return FontStyleNormal; |
2101 default: | 2101 default: |
2102 break; | 2102 break; |
2103 } | 2103 } |
2104 ASSERT_NOT_REACHED(); | 2104 NOTREACHED(); |
2105 return FontStyleNormal; | 2105 return FontStyleNormal; |
2106 } | 2106 } |
2107 | 2107 |
2108 template <> | 2108 template <> |
2109 inline CSSIdentifierValue::CSSIdentifierValue(FontStretch stretch) | 2109 inline CSSIdentifierValue::CSSIdentifierValue(FontStretch stretch) |
2110 : CSSValue(IdentifierClass) { | 2110 : CSSValue(IdentifierClass) { |
2111 switch (stretch) { | 2111 switch (stretch) { |
2112 case FontStretchUltraCondensed: | 2112 case FontStretchUltraCondensed: |
2113 m_valueID = CSSValueUltraCondensed; | 2113 m_valueID = CSSValueUltraCondensed; |
2114 return; | 2114 return; |
(...skipping 16 matching lines...) Expand all Loading... |
2131 m_valueID = CSSValueExpanded; | 2131 m_valueID = CSSValueExpanded; |
2132 return; | 2132 return; |
2133 case FontStretchExtraExpanded: | 2133 case FontStretchExtraExpanded: |
2134 m_valueID = CSSValueExtraExpanded; | 2134 m_valueID = CSSValueExtraExpanded; |
2135 return; | 2135 return; |
2136 case FontStretchUltraExpanded: | 2136 case FontStretchUltraExpanded: |
2137 m_valueID = CSSValueUltraExpanded; | 2137 m_valueID = CSSValueUltraExpanded; |
2138 return; | 2138 return; |
2139 } | 2139 } |
2140 | 2140 |
2141 ASSERT_NOT_REACHED(); | 2141 NOTREACHED(); |
2142 m_valueID = CSSValueNormal; | 2142 m_valueID = CSSValueNormal; |
2143 } | 2143 } |
2144 | 2144 |
2145 template <> | 2145 template <> |
2146 inline FontStretch CSSIdentifierValue::convertTo() const { | 2146 inline FontStretch CSSIdentifierValue::convertTo() const { |
2147 switch (m_valueID) { | 2147 switch (m_valueID) { |
2148 case CSSValueUltraCondensed: | 2148 case CSSValueUltraCondensed: |
2149 return FontStretchUltraCondensed; | 2149 return FontStretchUltraCondensed; |
2150 case CSSValueExtraCondensed: | 2150 case CSSValueExtraCondensed: |
2151 return FontStretchExtraCondensed; | 2151 return FontStretchExtraCondensed; |
2152 case CSSValueCondensed: | 2152 case CSSValueCondensed: |
2153 return FontStretchCondensed; | 2153 return FontStretchCondensed; |
2154 case CSSValueSemiCondensed: | 2154 case CSSValueSemiCondensed: |
2155 return FontStretchSemiCondensed; | 2155 return FontStretchSemiCondensed; |
2156 case CSSValueNormal: | 2156 case CSSValueNormal: |
2157 return FontStretchNormal; | 2157 return FontStretchNormal; |
2158 case CSSValueSemiExpanded: | 2158 case CSSValueSemiExpanded: |
2159 return FontStretchSemiExpanded; | 2159 return FontStretchSemiExpanded; |
2160 case CSSValueExpanded: | 2160 case CSSValueExpanded: |
2161 return FontStretchExpanded; | 2161 return FontStretchExpanded; |
2162 case CSSValueExtraExpanded: | 2162 case CSSValueExtraExpanded: |
2163 return FontStretchExtraExpanded; | 2163 return FontStretchExtraExpanded; |
2164 case CSSValueUltraExpanded: | 2164 case CSSValueUltraExpanded: |
2165 return FontStretchUltraExpanded; | 2165 return FontStretchUltraExpanded; |
2166 default: | 2166 default: |
2167 break; | 2167 break; |
2168 } | 2168 } |
2169 | 2169 |
2170 ASSERT_NOT_REACHED(); | 2170 NOTREACHED(); |
2171 return FontStretchNormal; | 2171 return FontStretchNormal; |
2172 } | 2172 } |
2173 | 2173 |
2174 template <> | 2174 template <> |
2175 inline CSSIdentifierValue::CSSIdentifierValue(TextRenderingMode e) | 2175 inline CSSIdentifierValue::CSSIdentifierValue(TextRenderingMode e) |
2176 : CSSValue(IdentifierClass) { | 2176 : CSSValue(IdentifierClass) { |
2177 switch (e) { | 2177 switch (e) { |
2178 case AutoTextRendering: | 2178 case AutoTextRendering: |
2179 m_valueID = CSSValueAuto; | 2179 m_valueID = CSSValueAuto; |
2180 break; | 2180 break; |
(...skipping 17 matching lines...) Expand all Loading... |
2198 case CSSValueOptimizeSpeed: | 2198 case CSSValueOptimizeSpeed: |
2199 return OptimizeSpeed; | 2199 return OptimizeSpeed; |
2200 case CSSValueOptimizeLegibility: | 2200 case CSSValueOptimizeLegibility: |
2201 return OptimizeLegibility; | 2201 return OptimizeLegibility; |
2202 case CSSValueGeometricPrecision: | 2202 case CSSValueGeometricPrecision: |
2203 return GeometricPrecision; | 2203 return GeometricPrecision; |
2204 default: | 2204 default: |
2205 break; | 2205 break; |
2206 } | 2206 } |
2207 | 2207 |
2208 ASSERT_NOT_REACHED(); | 2208 NOTREACHED(); |
2209 return AutoTextRendering; | 2209 return AutoTextRendering; |
2210 } | 2210 } |
2211 | 2211 |
2212 template <> | 2212 template <> |
2213 inline CSSIdentifierValue::CSSIdentifierValue(ESpeak e) | 2213 inline CSSIdentifierValue::CSSIdentifierValue(ESpeak e) |
2214 : CSSValue(IdentifierClass) { | 2214 : CSSValue(IdentifierClass) { |
2215 switch (e) { | 2215 switch (e) { |
2216 case SpeakNone: | 2216 case SpeakNone: |
2217 m_valueID = CSSValueNone; | 2217 m_valueID = CSSValueNone; |
2218 break; | 2218 break; |
(...skipping 19 matching lines...) Expand all Loading... |
2238 inline EOrder CSSIdentifierValue::convertTo() const { | 2238 inline EOrder CSSIdentifierValue::convertTo() const { |
2239 switch (m_valueID) { | 2239 switch (m_valueID) { |
2240 case CSSValueLogical: | 2240 case CSSValueLogical: |
2241 return EOrder::kLogical; | 2241 return EOrder::kLogical; |
2242 case CSSValueVisual: | 2242 case CSSValueVisual: |
2243 return EOrder::kVisual; | 2243 return EOrder::kVisual; |
2244 default: | 2244 default: |
2245 break; | 2245 break; |
2246 } | 2246 } |
2247 | 2247 |
2248 ASSERT_NOT_REACHED(); | 2248 NOTREACHED(); |
2249 return EOrder::kLogical; | 2249 return EOrder::kLogical; |
2250 } | 2250 } |
2251 | 2251 |
2252 template <> | 2252 template <> |
2253 inline CSSIdentifierValue::CSSIdentifierValue(EOrder e) | 2253 inline CSSIdentifierValue::CSSIdentifierValue(EOrder e) |
2254 : CSSValue(IdentifierClass) { | 2254 : CSSValue(IdentifierClass) { |
2255 switch (e) { | 2255 switch (e) { |
2256 case EOrder::kLogical: | 2256 case EOrder::kLogical: |
2257 m_valueID = CSSValueLogical; | 2257 m_valueID = CSSValueLogical; |
2258 break; | 2258 break; |
(...skipping 15 matching lines...) Expand all Loading... |
2274 case CSSValueDigits: | 2274 case CSSValueDigits: |
2275 return SpeakDigits; | 2275 return SpeakDigits; |
2276 case CSSValueLiteralPunctuation: | 2276 case CSSValueLiteralPunctuation: |
2277 return SpeakLiteralPunctuation; | 2277 return SpeakLiteralPunctuation; |
2278 case CSSValueNoPunctuation: | 2278 case CSSValueNoPunctuation: |
2279 return SpeakNoPunctuation; | 2279 return SpeakNoPunctuation; |
2280 default: | 2280 default: |
2281 break; | 2281 break; |
2282 } | 2282 } |
2283 | 2283 |
2284 ASSERT_NOT_REACHED(); | 2284 NOTREACHED(); |
2285 return SpeakNormal; | 2285 return SpeakNormal; |
2286 } | 2286 } |
2287 | 2287 |
2288 template <> | 2288 template <> |
2289 inline CSSIdentifierValue::CSSIdentifierValue(WebBlendMode blendMode) | 2289 inline CSSIdentifierValue::CSSIdentifierValue(WebBlendMode blendMode) |
2290 : CSSValue(IdentifierClass) { | 2290 : CSSValue(IdentifierClass) { |
2291 switch (blendMode) { | 2291 switch (blendMode) { |
2292 case WebBlendModeNormal: | 2292 case WebBlendModeNormal: |
2293 m_valueID = CSSValueNormal; | 2293 m_valueID = CSSValueNormal; |
2294 break; | 2294 break; |
(...skipping 77 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2372 case CSSValueSaturation: | 2372 case CSSValueSaturation: |
2373 return WebBlendModeSaturation; | 2373 return WebBlendModeSaturation; |
2374 case CSSValueColor: | 2374 case CSSValueColor: |
2375 return WebBlendModeColor; | 2375 return WebBlendModeColor; |
2376 case CSSValueLuminosity: | 2376 case CSSValueLuminosity: |
2377 return WebBlendModeLuminosity; | 2377 return WebBlendModeLuminosity; |
2378 default: | 2378 default: |
2379 break; | 2379 break; |
2380 } | 2380 } |
2381 | 2381 |
2382 ASSERT_NOT_REACHED(); | 2382 NOTREACHED(); |
2383 return WebBlendModeNormal; | 2383 return WebBlendModeNormal; |
2384 } | 2384 } |
2385 | 2385 |
2386 template <> | 2386 template <> |
2387 inline CSSIdentifierValue::CSSIdentifierValue(LineCap e) | 2387 inline CSSIdentifierValue::CSSIdentifierValue(LineCap e) |
2388 : CSSValue(IdentifierClass) { | 2388 : CSSValue(IdentifierClass) { |
2389 switch (e) { | 2389 switch (e) { |
2390 case ButtCap: | 2390 case ButtCap: |
2391 m_valueID = CSSValueButt; | 2391 m_valueID = CSSValueButt; |
2392 break; | 2392 break; |
(...skipping 12 matching lines...) Expand all Loading... |
2405 case CSSValueButt: | 2405 case CSSValueButt: |
2406 return ButtCap; | 2406 return ButtCap; |
2407 case CSSValueRound: | 2407 case CSSValueRound: |
2408 return RoundCap; | 2408 return RoundCap; |
2409 case CSSValueSquare: | 2409 case CSSValueSquare: |
2410 return SquareCap; | 2410 return SquareCap; |
2411 default: | 2411 default: |
2412 break; | 2412 break; |
2413 } | 2413 } |
2414 | 2414 |
2415 ASSERT_NOT_REACHED(); | 2415 NOTREACHED(); |
2416 return ButtCap; | 2416 return ButtCap; |
2417 } | 2417 } |
2418 | 2418 |
2419 template <> | 2419 template <> |
2420 inline CSSIdentifierValue::CSSIdentifierValue(LineJoin e) | 2420 inline CSSIdentifierValue::CSSIdentifierValue(LineJoin e) |
2421 : CSSValue(IdentifierClass) { | 2421 : CSSValue(IdentifierClass) { |
2422 switch (e) { | 2422 switch (e) { |
2423 case MiterJoin: | 2423 case MiterJoin: |
2424 m_valueID = CSSValueMiter; | 2424 m_valueID = CSSValueMiter; |
2425 break; | 2425 break; |
(...skipping 12 matching lines...) Expand all Loading... |
2438 case CSSValueMiter: | 2438 case CSSValueMiter: |
2439 return MiterJoin; | 2439 return MiterJoin; |
2440 case CSSValueRound: | 2440 case CSSValueRound: |
2441 return RoundJoin; | 2441 return RoundJoin; |
2442 case CSSValueBevel: | 2442 case CSSValueBevel: |
2443 return BevelJoin; | 2443 return BevelJoin; |
2444 default: | 2444 default: |
2445 break; | 2445 break; |
2446 } | 2446 } |
2447 | 2447 |
2448 ASSERT_NOT_REACHED(); | 2448 NOTREACHED(); |
2449 return MiterJoin; | 2449 return MiterJoin; |
2450 } | 2450 } |
2451 | 2451 |
2452 template <> | 2452 template <> |
2453 inline CSSIdentifierValue::CSSIdentifierValue(WindRule e) | 2453 inline CSSIdentifierValue::CSSIdentifierValue(WindRule e) |
2454 : CSSValue(IdentifierClass) { | 2454 : CSSValue(IdentifierClass) { |
2455 switch (e) { | 2455 switch (e) { |
2456 case RULE_NONZERO: | 2456 case RULE_NONZERO: |
2457 m_valueID = CSSValueNonzero; | 2457 m_valueID = CSSValueNonzero; |
2458 break; | 2458 break; |
2459 case RULE_EVENODD: | 2459 case RULE_EVENODD: |
2460 m_valueID = CSSValueEvenodd; | 2460 m_valueID = CSSValueEvenodd; |
2461 break; | 2461 break; |
2462 } | 2462 } |
2463 } | 2463 } |
2464 | 2464 |
2465 template <> | 2465 template <> |
2466 inline WindRule CSSIdentifierValue::convertTo() const { | 2466 inline WindRule CSSIdentifierValue::convertTo() const { |
2467 switch (m_valueID) { | 2467 switch (m_valueID) { |
2468 case CSSValueNonzero: | 2468 case CSSValueNonzero: |
2469 return RULE_NONZERO; | 2469 return RULE_NONZERO; |
2470 case CSSValueEvenodd: | 2470 case CSSValueEvenodd: |
2471 return RULE_EVENODD; | 2471 return RULE_EVENODD; |
2472 default: | 2472 default: |
2473 break; | 2473 break; |
2474 } | 2474 } |
2475 | 2475 |
2476 ASSERT_NOT_REACHED(); | 2476 NOTREACHED(); |
2477 return RULE_NONZERO; | 2477 return RULE_NONZERO; |
2478 } | 2478 } |
2479 | 2479 |
2480 template <> | 2480 template <> |
2481 inline CSSIdentifierValue::CSSIdentifierValue(EAlignmentBaseline e) | 2481 inline CSSIdentifierValue::CSSIdentifierValue(EAlignmentBaseline e) |
2482 : CSSValue(IdentifierClass) { | 2482 : CSSValue(IdentifierClass) { |
2483 switch (e) { | 2483 switch (e) { |
2484 case AB_AUTO: | 2484 case AB_AUTO: |
2485 m_valueID = CSSValueAuto; | 2485 m_valueID = CSSValueAuto; |
2486 break; | 2486 break; |
(...skipping 57 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2544 case CSSValueAlphabetic: | 2544 case CSSValueAlphabetic: |
2545 return AB_ALPHABETIC; | 2545 return AB_ALPHABETIC; |
2546 case CSSValueHanging: | 2546 case CSSValueHanging: |
2547 return AB_HANGING; | 2547 return AB_HANGING; |
2548 case CSSValueMathematical: | 2548 case CSSValueMathematical: |
2549 return AB_MATHEMATICAL; | 2549 return AB_MATHEMATICAL; |
2550 default: | 2550 default: |
2551 break; | 2551 break; |
2552 } | 2552 } |
2553 | 2553 |
2554 ASSERT_NOT_REACHED(); | 2554 NOTREACHED(); |
2555 return AB_AUTO; | 2555 return AB_AUTO; |
2556 } | 2556 } |
2557 | 2557 |
2558 template <> | 2558 template <> |
2559 inline CSSIdentifierValue::CSSIdentifierValue(EImageRendering e) | 2559 inline CSSIdentifierValue::CSSIdentifierValue(EImageRendering e) |
2560 : CSSValue(IdentifierClass) { | 2560 : CSSValue(IdentifierClass) { |
2561 switch (e) { | 2561 switch (e) { |
2562 case ImageRenderingAuto: | 2562 case ImageRenderingAuto: |
2563 m_valueID = CSSValueAuto; | 2563 m_valueID = CSSValueAuto; |
2564 break; | 2564 break; |
(...skipping 22 matching lines...) Expand all Loading... |
2587 case CSSValueOptimizeQuality: | 2587 case CSSValueOptimizeQuality: |
2588 return ImageRenderingOptimizeQuality; | 2588 return ImageRenderingOptimizeQuality; |
2589 case CSSValuePixelated: | 2589 case CSSValuePixelated: |
2590 return ImageRenderingPixelated; | 2590 return ImageRenderingPixelated; |
2591 case CSSValueWebkitOptimizeContrast: | 2591 case CSSValueWebkitOptimizeContrast: |
2592 return ImageRenderingOptimizeContrast; | 2592 return ImageRenderingOptimizeContrast; |
2593 default: | 2593 default: |
2594 break; | 2594 break; |
2595 } | 2595 } |
2596 | 2596 |
2597 ASSERT_NOT_REACHED(); | 2597 NOTREACHED(); |
2598 return ImageRenderingAuto; | 2598 return ImageRenderingAuto; |
2599 } | 2599 } |
2600 | 2600 |
2601 template <> | 2601 template <> |
2602 inline CSSIdentifierValue::CSSIdentifierValue(ETransformStyle3D e) | 2602 inline CSSIdentifierValue::CSSIdentifierValue(ETransformStyle3D e) |
2603 : CSSValue(IdentifierClass) { | 2603 : CSSValue(IdentifierClass) { |
2604 switch (e) { | 2604 switch (e) { |
2605 case TransformStyle3DFlat: | 2605 case TransformStyle3DFlat: |
2606 m_valueID = CSSValueFlat; | 2606 m_valueID = CSSValueFlat; |
2607 break; | 2607 break; |
2608 case TransformStyle3DPreserve3D: | 2608 case TransformStyle3DPreserve3D: |
2609 m_valueID = CSSValuePreserve3d; | 2609 m_valueID = CSSValuePreserve3d; |
2610 break; | 2610 break; |
2611 } | 2611 } |
2612 } | 2612 } |
2613 | 2613 |
2614 template <> | 2614 template <> |
2615 inline ETransformStyle3D CSSIdentifierValue::convertTo() const { | 2615 inline ETransformStyle3D CSSIdentifierValue::convertTo() const { |
2616 switch (m_valueID) { | 2616 switch (m_valueID) { |
2617 case CSSValueFlat: | 2617 case CSSValueFlat: |
2618 return TransformStyle3DFlat; | 2618 return TransformStyle3DFlat; |
2619 case CSSValuePreserve3d: | 2619 case CSSValuePreserve3d: |
2620 return TransformStyle3DPreserve3D; | 2620 return TransformStyle3DPreserve3D; |
2621 default: | 2621 default: |
2622 break; | 2622 break; |
2623 } | 2623 } |
2624 | 2624 |
2625 ASSERT_NOT_REACHED(); | 2625 NOTREACHED(); |
2626 return TransformStyle3DFlat; | 2626 return TransformStyle3DFlat; |
2627 } | 2627 } |
2628 | 2628 |
2629 template <> | 2629 template <> |
2630 inline CSSIdentifierValue::CSSIdentifierValue(EBufferedRendering e) | 2630 inline CSSIdentifierValue::CSSIdentifierValue(EBufferedRendering e) |
2631 : CSSValue(IdentifierClass) { | 2631 : CSSValue(IdentifierClass) { |
2632 switch (e) { | 2632 switch (e) { |
2633 case BR_AUTO: | 2633 case BR_AUTO: |
2634 m_valueID = CSSValueAuto; | 2634 m_valueID = CSSValueAuto; |
2635 break; | 2635 break; |
(...skipping 12 matching lines...) Expand all Loading... |
2648 case CSSValueAuto: | 2648 case CSSValueAuto: |
2649 return BR_AUTO; | 2649 return BR_AUTO; |
2650 case CSSValueDynamic: | 2650 case CSSValueDynamic: |
2651 return BR_DYNAMIC; | 2651 return BR_DYNAMIC; |
2652 case CSSValueStatic: | 2652 case CSSValueStatic: |
2653 return BR_STATIC; | 2653 return BR_STATIC; |
2654 default: | 2654 default: |
2655 break; | 2655 break; |
2656 } | 2656 } |
2657 | 2657 |
2658 ASSERT_NOT_REACHED(); | 2658 NOTREACHED(); |
2659 return BR_AUTO; | 2659 return BR_AUTO; |
2660 } | 2660 } |
2661 | 2661 |
2662 template <> | 2662 template <> |
2663 inline CSSIdentifierValue::CSSIdentifierValue(EColorInterpolation e) | 2663 inline CSSIdentifierValue::CSSIdentifierValue(EColorInterpolation e) |
2664 : CSSValue(IdentifierClass) { | 2664 : CSSValue(IdentifierClass) { |
2665 switch (e) { | 2665 switch (e) { |
2666 case CI_AUTO: | 2666 case CI_AUTO: |
2667 m_valueID = CSSValueAuto; | 2667 m_valueID = CSSValueAuto; |
2668 break; | 2668 break; |
(...skipping 12 matching lines...) Expand all Loading... |
2681 case CSSValueSRGB: | 2681 case CSSValueSRGB: |
2682 return CI_SRGB; | 2682 return CI_SRGB; |
2683 case CSSValueLinearRGB: | 2683 case CSSValueLinearRGB: |
2684 return CI_LINEARRGB; | 2684 return CI_LINEARRGB; |
2685 case CSSValueAuto: | 2685 case CSSValueAuto: |
2686 return CI_AUTO; | 2686 return CI_AUTO; |
2687 default: | 2687 default: |
2688 break; | 2688 break; |
2689 } | 2689 } |
2690 | 2690 |
2691 ASSERT_NOT_REACHED(); | 2691 NOTREACHED(); |
2692 return CI_AUTO; | 2692 return CI_AUTO; |
2693 } | 2693 } |
2694 | 2694 |
2695 template <> | 2695 template <> |
2696 inline CSSIdentifierValue::CSSIdentifierValue(EColorRendering e) | 2696 inline CSSIdentifierValue::CSSIdentifierValue(EColorRendering e) |
2697 : CSSValue(IdentifierClass) { | 2697 : CSSValue(IdentifierClass) { |
2698 switch (e) { | 2698 switch (e) { |
2699 case CR_AUTO: | 2699 case CR_AUTO: |
2700 m_valueID = CSSValueAuto; | 2700 m_valueID = CSSValueAuto; |
2701 break; | 2701 break; |
(...skipping 12 matching lines...) Expand all Loading... |
2714 case CSSValueOptimizeSpeed: | 2714 case CSSValueOptimizeSpeed: |
2715 return CR_OPTIMIZESPEED; | 2715 return CR_OPTIMIZESPEED; |
2716 case CSSValueOptimizeQuality: | 2716 case CSSValueOptimizeQuality: |
2717 return CR_OPTIMIZEQUALITY; | 2717 return CR_OPTIMIZEQUALITY; |
2718 case CSSValueAuto: | 2718 case CSSValueAuto: |
2719 return CR_AUTO; | 2719 return CR_AUTO; |
2720 default: | 2720 default: |
2721 break; | 2721 break; |
2722 } | 2722 } |
2723 | 2723 |
2724 ASSERT_NOT_REACHED(); | 2724 NOTREACHED(); |
2725 return CR_AUTO; | 2725 return CR_AUTO; |
2726 } | 2726 } |
2727 | 2727 |
2728 template <> | 2728 template <> |
2729 inline CSSIdentifierValue::CSSIdentifierValue(EDominantBaseline e) | 2729 inline CSSIdentifierValue::CSSIdentifierValue(EDominantBaseline e) |
2730 : CSSValue(IdentifierClass) { | 2730 : CSSValue(IdentifierClass) { |
2731 switch (e) { | 2731 switch (e) { |
2732 case DB_AUTO: | 2732 case DB_AUTO: |
2733 m_valueID = CSSValueAuto; | 2733 m_valueID = CSSValueAuto; |
2734 break; | 2734 break; |
(...skipping 57 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2792 case CSSValueMiddle: | 2792 case CSSValueMiddle: |
2793 return DB_MIDDLE; | 2793 return DB_MIDDLE; |
2794 case CSSValueTextAfterEdge: | 2794 case CSSValueTextAfterEdge: |
2795 return DB_TEXT_AFTER_EDGE; | 2795 return DB_TEXT_AFTER_EDGE; |
2796 case CSSValueTextBeforeEdge: | 2796 case CSSValueTextBeforeEdge: |
2797 return DB_TEXT_BEFORE_EDGE; | 2797 return DB_TEXT_BEFORE_EDGE; |
2798 default: | 2798 default: |
2799 break; | 2799 break; |
2800 } | 2800 } |
2801 | 2801 |
2802 ASSERT_NOT_REACHED(); | 2802 NOTREACHED(); |
2803 return DB_AUTO; | 2803 return DB_AUTO; |
2804 } | 2804 } |
2805 | 2805 |
2806 template <> | 2806 template <> |
2807 inline CSSIdentifierValue::CSSIdentifierValue(EShapeRendering e) | 2807 inline CSSIdentifierValue::CSSIdentifierValue(EShapeRendering e) |
2808 : CSSValue(IdentifierClass) { | 2808 : CSSValue(IdentifierClass) { |
2809 switch (e) { | 2809 switch (e) { |
2810 case SR_AUTO: | 2810 case SR_AUTO: |
2811 m_valueID = CSSValueAuto; | 2811 m_valueID = CSSValueAuto; |
2812 break; | 2812 break; |
(...skipping 17 matching lines...) Expand all Loading... |
2830 case CSSValueOptimizeSpeed: | 2830 case CSSValueOptimizeSpeed: |
2831 return SR_OPTIMIZESPEED; | 2831 return SR_OPTIMIZESPEED; |
2832 case CSSValueCrispEdges: | 2832 case CSSValueCrispEdges: |
2833 return SR_CRISPEDGES; | 2833 return SR_CRISPEDGES; |
2834 case CSSValueGeometricPrecision: | 2834 case CSSValueGeometricPrecision: |
2835 return SR_GEOMETRICPRECISION; | 2835 return SR_GEOMETRICPRECISION; |
2836 default: | 2836 default: |
2837 break; | 2837 break; |
2838 } | 2838 } |
2839 | 2839 |
2840 ASSERT_NOT_REACHED(); | 2840 NOTREACHED(); |
2841 return SR_AUTO; | 2841 return SR_AUTO; |
2842 } | 2842 } |
2843 | 2843 |
2844 template <> | 2844 template <> |
2845 inline CSSIdentifierValue::CSSIdentifierValue(ETextAnchor e) | 2845 inline CSSIdentifierValue::CSSIdentifierValue(ETextAnchor e) |
2846 : CSSValue(IdentifierClass) { | 2846 : CSSValue(IdentifierClass) { |
2847 switch (e) { | 2847 switch (e) { |
2848 case TA_START: | 2848 case TA_START: |
2849 m_valueID = CSSValueStart; | 2849 m_valueID = CSSValueStart; |
2850 break; | 2850 break; |
(...skipping 12 matching lines...) Expand all Loading... |
2863 case CSSValueStart: | 2863 case CSSValueStart: |
2864 return TA_START; | 2864 return TA_START; |
2865 case CSSValueMiddle: | 2865 case CSSValueMiddle: |
2866 return TA_MIDDLE; | 2866 return TA_MIDDLE; |
2867 case CSSValueEnd: | 2867 case CSSValueEnd: |
2868 return TA_END; | 2868 return TA_END; |
2869 default: | 2869 default: |
2870 break; | 2870 break; |
2871 } | 2871 } |
2872 | 2872 |
2873 ASSERT_NOT_REACHED(); | 2873 NOTREACHED(); |
2874 return TA_START; | 2874 return TA_START; |
2875 } | 2875 } |
2876 | 2876 |
2877 template <> | 2877 template <> |
2878 inline CSSIdentifierValue::CSSIdentifierValue(EVectorEffect e) | 2878 inline CSSIdentifierValue::CSSIdentifierValue(EVectorEffect e) |
2879 : CSSValue(IdentifierClass) { | 2879 : CSSValue(IdentifierClass) { |
2880 switch (e) { | 2880 switch (e) { |
2881 case VE_NONE: | 2881 case VE_NONE: |
2882 m_valueID = CSSValueNone; | 2882 m_valueID = CSSValueNone; |
2883 break; | 2883 break; |
2884 case VE_NON_SCALING_STROKE: | 2884 case VE_NON_SCALING_STROKE: |
2885 m_valueID = CSSValueNonScalingStroke; | 2885 m_valueID = CSSValueNonScalingStroke; |
2886 break; | 2886 break; |
2887 } | 2887 } |
2888 } | 2888 } |
2889 | 2889 |
2890 template <> | 2890 template <> |
2891 inline EVectorEffect CSSIdentifierValue::convertTo() const { | 2891 inline EVectorEffect CSSIdentifierValue::convertTo() const { |
2892 switch (m_valueID) { | 2892 switch (m_valueID) { |
2893 case CSSValueNone: | 2893 case CSSValueNone: |
2894 return VE_NONE; | 2894 return VE_NONE; |
2895 case CSSValueNonScalingStroke: | 2895 case CSSValueNonScalingStroke: |
2896 return VE_NON_SCALING_STROKE; | 2896 return VE_NON_SCALING_STROKE; |
2897 default: | 2897 default: |
2898 break; | 2898 break; |
2899 } | 2899 } |
2900 | 2900 |
2901 ASSERT_NOT_REACHED(); | 2901 NOTREACHED(); |
2902 return VE_NONE; | 2902 return VE_NONE; |
2903 } | 2903 } |
2904 | 2904 |
2905 template <> | 2905 template <> |
2906 inline CSSIdentifierValue::CSSIdentifierValue(EPaintOrderType e) | 2906 inline CSSIdentifierValue::CSSIdentifierValue(EPaintOrderType e) |
2907 : CSSValue(IdentifierClass) { | 2907 : CSSValue(IdentifierClass) { |
2908 switch (e) { | 2908 switch (e) { |
2909 case PT_FILL: | 2909 case PT_FILL: |
2910 m_valueID = CSSValueFill; | 2910 m_valueID = CSSValueFill; |
2911 break; | 2911 break; |
2912 case PT_STROKE: | 2912 case PT_STROKE: |
2913 m_valueID = CSSValueStroke; | 2913 m_valueID = CSSValueStroke; |
2914 break; | 2914 break; |
2915 case PT_MARKERS: | 2915 case PT_MARKERS: |
2916 m_valueID = CSSValueMarkers; | 2916 m_valueID = CSSValueMarkers; |
2917 break; | 2917 break; |
2918 default: | 2918 default: |
2919 ASSERT_NOT_REACHED(); | 2919 NOTREACHED(); |
2920 m_valueID = CSSValueFill; | 2920 m_valueID = CSSValueFill; |
2921 break; | 2921 break; |
2922 } | 2922 } |
2923 } | 2923 } |
2924 | 2924 |
2925 template <> | 2925 template <> |
2926 inline EPaintOrderType CSSIdentifierValue::convertTo() const { | 2926 inline EPaintOrderType CSSIdentifierValue::convertTo() const { |
2927 switch (m_valueID) { | 2927 switch (m_valueID) { |
2928 case CSSValueFill: | 2928 case CSSValueFill: |
2929 return PT_FILL; | 2929 return PT_FILL; |
2930 case CSSValueStroke: | 2930 case CSSValueStroke: |
2931 return PT_STROKE; | 2931 return PT_STROKE; |
2932 case CSSValueMarkers: | 2932 case CSSValueMarkers: |
2933 return PT_MARKERS; | 2933 return PT_MARKERS; |
2934 default: | 2934 default: |
2935 break; | 2935 break; |
2936 } | 2936 } |
2937 | 2937 |
2938 ASSERT_NOT_REACHED(); | 2938 NOTREACHED(); |
2939 return PT_NONE; | 2939 return PT_NONE; |
2940 } | 2940 } |
2941 | 2941 |
2942 template <> | 2942 template <> |
2943 inline CSSIdentifierValue::CSSIdentifierValue(EMaskType e) | 2943 inline CSSIdentifierValue::CSSIdentifierValue(EMaskType e) |
2944 : CSSValue(IdentifierClass) { | 2944 : CSSValue(IdentifierClass) { |
2945 switch (e) { | 2945 switch (e) { |
2946 case MT_LUMINANCE: | 2946 case MT_LUMINANCE: |
2947 m_valueID = CSSValueLuminance; | 2947 m_valueID = CSSValueLuminance; |
2948 break; | 2948 break; |
2949 case MT_ALPHA: | 2949 case MT_ALPHA: |
2950 m_valueID = CSSValueAlpha; | 2950 m_valueID = CSSValueAlpha; |
2951 break; | 2951 break; |
2952 } | 2952 } |
2953 } | 2953 } |
2954 | 2954 |
2955 template <> | 2955 template <> |
2956 inline EMaskType CSSIdentifierValue::convertTo() const { | 2956 inline EMaskType CSSIdentifierValue::convertTo() const { |
2957 switch (m_valueID) { | 2957 switch (m_valueID) { |
2958 case CSSValueLuminance: | 2958 case CSSValueLuminance: |
2959 return MT_LUMINANCE; | 2959 return MT_LUMINANCE; |
2960 case CSSValueAlpha: | 2960 case CSSValueAlpha: |
2961 return MT_ALPHA; | 2961 return MT_ALPHA; |
2962 default: | 2962 default: |
2963 break; | 2963 break; |
2964 } | 2964 } |
2965 | 2965 |
2966 ASSERT_NOT_REACHED(); | 2966 NOTREACHED(); |
2967 return MT_LUMINANCE; | 2967 return MT_LUMINANCE; |
2968 } | 2968 } |
2969 | 2969 |
2970 template <> | 2970 template <> |
2971 inline TouchAction CSSIdentifierValue::convertTo() const { | 2971 inline TouchAction CSSIdentifierValue::convertTo() const { |
2972 switch (m_valueID) { | 2972 switch (m_valueID) { |
2973 case CSSValueNone: | 2973 case CSSValueNone: |
2974 return TouchActionNone; | 2974 return TouchActionNone; |
2975 case CSSValueAuto: | 2975 case CSSValueAuto: |
2976 return TouchActionAuto; | 2976 return TouchActionAuto; |
(...skipping 10 matching lines...) Expand all Loading... |
2987 case CSSValuePanY: | 2987 case CSSValuePanY: |
2988 return TouchActionPanY; | 2988 return TouchActionPanY; |
2989 case CSSValueManipulation: | 2989 case CSSValueManipulation: |
2990 return TouchActionManipulation; | 2990 return TouchActionManipulation; |
2991 case CSSValuePinchZoom: | 2991 case CSSValuePinchZoom: |
2992 return TouchActionPinchZoom; | 2992 return TouchActionPinchZoom; |
2993 default: | 2993 default: |
2994 break; | 2994 break; |
2995 } | 2995 } |
2996 | 2996 |
2997 ASSERT_NOT_REACHED(); | 2997 NOTREACHED(); |
2998 return TouchActionNone; | 2998 return TouchActionNone; |
2999 } | 2999 } |
3000 | 3000 |
3001 template <> | 3001 template <> |
3002 inline CSSIdentifierValue::CSSIdentifierValue(EIsolation i) | 3002 inline CSSIdentifierValue::CSSIdentifierValue(EIsolation i) |
3003 : CSSValue(IdentifierClass) { | 3003 : CSSValue(IdentifierClass) { |
3004 switch (i) { | 3004 switch (i) { |
3005 case IsolationAuto: | 3005 case IsolationAuto: |
3006 m_valueID = CSSValueAuto; | 3006 m_valueID = CSSValueAuto; |
3007 break; | 3007 break; |
3008 case IsolationIsolate: | 3008 case IsolationIsolate: |
3009 m_valueID = CSSValueIsolate; | 3009 m_valueID = CSSValueIsolate; |
3010 break; | 3010 break; |
3011 } | 3011 } |
3012 } | 3012 } |
3013 | 3013 |
3014 template <> | 3014 template <> |
3015 inline EIsolation CSSIdentifierValue::convertTo() const { | 3015 inline EIsolation CSSIdentifierValue::convertTo() const { |
3016 switch (m_valueID) { | 3016 switch (m_valueID) { |
3017 case CSSValueAuto: | 3017 case CSSValueAuto: |
3018 return IsolationAuto; | 3018 return IsolationAuto; |
3019 case CSSValueIsolate: | 3019 case CSSValueIsolate: |
3020 return IsolationIsolate; | 3020 return IsolationIsolate; |
3021 default: | 3021 default: |
3022 break; | 3022 break; |
3023 } | 3023 } |
3024 | 3024 |
3025 ASSERT_NOT_REACHED(); | 3025 NOTREACHED(); |
3026 return IsolationAuto; | 3026 return IsolationAuto; |
3027 } | 3027 } |
3028 | 3028 |
3029 template <> | 3029 template <> |
3030 inline CSSIdentifierValue::CSSIdentifierValue(CSSBoxType cssBox) | 3030 inline CSSIdentifierValue::CSSIdentifierValue(CSSBoxType cssBox) |
3031 : CSSValue(IdentifierClass) { | 3031 : CSSValue(IdentifierClass) { |
3032 switch (cssBox) { | 3032 switch (cssBox) { |
3033 case MarginBox: | 3033 case MarginBox: |
3034 m_valueID = CSSValueMarginBox; | 3034 m_valueID = CSSValueMarginBox; |
3035 break; | 3035 break; |
3036 case BorderBox: | 3036 case BorderBox: |
3037 m_valueID = CSSValueBorderBox; | 3037 m_valueID = CSSValueBorderBox; |
3038 break; | 3038 break; |
3039 case PaddingBox: | 3039 case PaddingBox: |
3040 m_valueID = CSSValuePaddingBox; | 3040 m_valueID = CSSValuePaddingBox; |
3041 break; | 3041 break; |
3042 case ContentBox: | 3042 case ContentBox: |
3043 m_valueID = CSSValueContentBox; | 3043 m_valueID = CSSValueContentBox; |
3044 break; | 3044 break; |
3045 case BoxMissing: | 3045 case BoxMissing: |
3046 // The missing box should convert to a null primitive value. | 3046 // The missing box should convert to a null primitive value. |
3047 ASSERT_NOT_REACHED(); | 3047 NOTREACHED(); |
3048 } | 3048 } |
3049 } | 3049 } |
3050 | 3050 |
3051 template <> | 3051 template <> |
3052 inline CSSBoxType CSSIdentifierValue::convertTo() const { | 3052 inline CSSBoxType CSSIdentifierValue::convertTo() const { |
3053 switch (getValueID()) { | 3053 switch (getValueID()) { |
3054 case CSSValueMarginBox: | 3054 case CSSValueMarginBox: |
3055 return MarginBox; | 3055 return MarginBox; |
3056 case CSSValueBorderBox: | 3056 case CSSValueBorderBox: |
3057 return BorderBox; | 3057 return BorderBox; |
3058 case CSSValuePaddingBox: | 3058 case CSSValuePaddingBox: |
3059 return PaddingBox; | 3059 return PaddingBox; |
3060 case CSSValueContentBox: | 3060 case CSSValueContentBox: |
3061 return ContentBox; | 3061 return ContentBox; |
3062 default: | 3062 default: |
3063 break; | 3063 break; |
3064 } | 3064 } |
3065 ASSERT_NOT_REACHED(); | 3065 NOTREACHED(); |
3066 return ContentBox; | 3066 return ContentBox; |
3067 } | 3067 } |
3068 | 3068 |
3069 template <> | 3069 template <> |
3070 inline CSSIdentifierValue::CSSIdentifierValue(ItemPosition itemPosition) | 3070 inline CSSIdentifierValue::CSSIdentifierValue(ItemPosition itemPosition) |
3071 : CSSValue(IdentifierClass) { | 3071 : CSSValue(IdentifierClass) { |
3072 switch (itemPosition) { | 3072 switch (itemPosition) { |
3073 case ItemPositionAuto: | 3073 case ItemPositionAuto: |
3074 // The 'auto' values might have been already resolved. | 3074 // The 'auto' values might have been already resolved. |
3075 NOTREACHED(); | 3075 NOTREACHED(); |
(...skipping 70 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3146 return ItemPositionFlexStart; | 3146 return ItemPositionFlexStart; |
3147 case CSSValueFlexEnd: | 3147 case CSSValueFlexEnd: |
3148 return ItemPositionFlexEnd; | 3148 return ItemPositionFlexEnd; |
3149 case CSSValueLeft: | 3149 case CSSValueLeft: |
3150 return ItemPositionLeft; | 3150 return ItemPositionLeft; |
3151 case CSSValueRight: | 3151 case CSSValueRight: |
3152 return ItemPositionRight; | 3152 return ItemPositionRight; |
3153 default: | 3153 default: |
3154 break; | 3154 break; |
3155 } | 3155 } |
3156 ASSERT_NOT_REACHED(); | 3156 NOTREACHED(); |
3157 return ItemPositionAuto; | 3157 return ItemPositionAuto; |
3158 } | 3158 } |
3159 | 3159 |
3160 template <> | 3160 template <> |
3161 inline CSSIdentifierValue::CSSIdentifierValue(ContentPosition contentPosition) | 3161 inline CSSIdentifierValue::CSSIdentifierValue(ContentPosition contentPosition) |
3162 : CSSValue(IdentifierClass) { | 3162 : CSSValue(IdentifierClass) { |
3163 switch (contentPosition) { | 3163 switch (contentPosition) { |
3164 case ContentPositionNormal: | 3164 case ContentPositionNormal: |
3165 m_valueID = CSSValueNormal; | 3165 m_valueID = CSSValueNormal; |
3166 break; | 3166 break; |
(...skipping 48 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3215 return ContentPositionFlexStart; | 3215 return ContentPositionFlexStart; |
3216 case CSSValueFlexEnd: | 3216 case CSSValueFlexEnd: |
3217 return ContentPositionFlexEnd; | 3217 return ContentPositionFlexEnd; |
3218 case CSSValueLeft: | 3218 case CSSValueLeft: |
3219 return ContentPositionLeft; | 3219 return ContentPositionLeft; |
3220 case CSSValueRight: | 3220 case CSSValueRight: |
3221 return ContentPositionRight; | 3221 return ContentPositionRight; |
3222 default: | 3222 default: |
3223 break; | 3223 break; |
3224 } | 3224 } |
3225 ASSERT_NOT_REACHED(); | 3225 NOTREACHED(); |
3226 return ContentPositionNormal; | 3226 return ContentPositionNormal; |
3227 } | 3227 } |
3228 | 3228 |
3229 template <> | 3229 template <> |
3230 inline CSSIdentifierValue::CSSIdentifierValue( | 3230 inline CSSIdentifierValue::CSSIdentifierValue( |
3231 ContentDistributionType contentDistribution) | 3231 ContentDistributionType contentDistribution) |
3232 : CSSValue(IdentifierClass) { | 3232 : CSSValue(IdentifierClass) { |
3233 switch (contentDistribution) { | 3233 switch (contentDistribution) { |
3234 case ContentDistributionDefault: | 3234 case ContentDistributionDefault: |
3235 m_valueID = CSSValueDefault; | 3235 m_valueID = CSSValueDefault; |
(...skipping 20 matching lines...) Expand all Loading... |
3256 return ContentDistributionSpaceBetween; | 3256 return ContentDistributionSpaceBetween; |
3257 case CSSValueSpaceAround: | 3257 case CSSValueSpaceAround: |
3258 return ContentDistributionSpaceAround; | 3258 return ContentDistributionSpaceAround; |
3259 case CSSValueSpaceEvenly: | 3259 case CSSValueSpaceEvenly: |
3260 return ContentDistributionSpaceEvenly; | 3260 return ContentDistributionSpaceEvenly; |
3261 case CSSValueStretch: | 3261 case CSSValueStretch: |
3262 return ContentDistributionStretch; | 3262 return ContentDistributionStretch; |
3263 default: | 3263 default: |
3264 break; | 3264 break; |
3265 } | 3265 } |
3266 ASSERT_NOT_REACHED(); | 3266 NOTREACHED(); |
3267 return ContentDistributionStretch; | 3267 return ContentDistributionStretch; |
3268 } | 3268 } |
3269 | 3269 |
3270 template <> | 3270 template <> |
3271 inline CSSIdentifierValue::CSSIdentifierValue( | 3271 inline CSSIdentifierValue::CSSIdentifierValue( |
3272 OverflowAlignment overflowAlignment) | 3272 OverflowAlignment overflowAlignment) |
3273 : CSSValue(IdentifierClass) { | 3273 : CSSValue(IdentifierClass) { |
3274 switch (overflowAlignment) { | 3274 switch (overflowAlignment) { |
3275 case OverflowAlignmentDefault: | 3275 case OverflowAlignmentDefault: |
3276 m_valueID = CSSValueDefault; | 3276 m_valueID = CSSValueDefault; |
(...skipping 10 matching lines...) Expand all Loading... |
3287 template <> | 3287 template <> |
3288 inline OverflowAlignment CSSIdentifierValue::convertTo() const { | 3288 inline OverflowAlignment CSSIdentifierValue::convertTo() const { |
3289 switch (m_valueID) { | 3289 switch (m_valueID) { |
3290 case CSSValueUnsafe: | 3290 case CSSValueUnsafe: |
3291 return OverflowAlignmentUnsafe; | 3291 return OverflowAlignmentUnsafe; |
3292 case CSSValueSafe: | 3292 case CSSValueSafe: |
3293 return OverflowAlignmentSafe; | 3293 return OverflowAlignmentSafe; |
3294 default: | 3294 default: |
3295 break; | 3295 break; |
3296 } | 3296 } |
3297 ASSERT_NOT_REACHED(); | 3297 NOTREACHED(); |
3298 return OverflowAlignmentUnsafe; | 3298 return OverflowAlignmentUnsafe; |
3299 } | 3299 } |
3300 | 3300 |
3301 template <> | 3301 template <> |
3302 inline CSSIdentifierValue::CSSIdentifierValue(ScrollBehavior behavior) | 3302 inline CSSIdentifierValue::CSSIdentifierValue(ScrollBehavior behavior) |
3303 : CSSValue(IdentifierClass) { | 3303 : CSSValue(IdentifierClass) { |
3304 switch (behavior) { | 3304 switch (behavior) { |
3305 case ScrollBehaviorAuto: | 3305 case ScrollBehaviorAuto: |
3306 m_valueID = CSSValueAuto; | 3306 m_valueID = CSSValueAuto; |
3307 break; | 3307 break; |
3308 case ScrollBehaviorSmooth: | 3308 case ScrollBehaviorSmooth: |
3309 m_valueID = CSSValueSmooth; | 3309 m_valueID = CSSValueSmooth; |
3310 break; | 3310 break; |
3311 case ScrollBehaviorInstant: | 3311 case ScrollBehaviorInstant: |
3312 // Behavior 'instant' is only allowed in ScrollOptions arguments passed to | 3312 // Behavior 'instant' is only allowed in ScrollOptions arguments passed to |
3313 // CSSOM scroll APIs. | 3313 // CSSOM scroll APIs. |
3314 ASSERT_NOT_REACHED(); | 3314 NOTREACHED(); |
3315 } | 3315 } |
3316 } | 3316 } |
3317 | 3317 |
3318 template <> | 3318 template <> |
3319 inline ScrollBehavior CSSIdentifierValue::convertTo() const { | 3319 inline ScrollBehavior CSSIdentifierValue::convertTo() const { |
3320 switch (getValueID()) { | 3320 switch (getValueID()) { |
3321 case CSSValueAuto: | 3321 case CSSValueAuto: |
3322 return ScrollBehaviorAuto; | 3322 return ScrollBehaviorAuto; |
3323 case CSSValueSmooth: | 3323 case CSSValueSmooth: |
3324 return ScrollBehaviorSmooth; | 3324 return ScrollBehaviorSmooth; |
3325 default: | 3325 default: |
3326 break; | 3326 break; |
3327 } | 3327 } |
3328 ASSERT_NOT_REACHED(); | 3328 NOTREACHED(); |
3329 return ScrollBehaviorAuto; | 3329 return ScrollBehaviorAuto; |
3330 } | 3330 } |
3331 | 3331 |
3332 template <> | 3332 template <> |
3333 inline CSSIdentifierValue::CSSIdentifierValue(ScrollSnapType snapType) | 3333 inline CSSIdentifierValue::CSSIdentifierValue(ScrollSnapType snapType) |
3334 : CSSValue(IdentifierClass) { | 3334 : CSSValue(IdentifierClass) { |
3335 switch (snapType) { | 3335 switch (snapType) { |
3336 case ScrollSnapTypeNone: | 3336 case ScrollSnapTypeNone: |
3337 m_valueID = CSSValueNone; | 3337 m_valueID = CSSValueNone; |
3338 break; | 3338 break; |
(...skipping 11 matching lines...) Expand all Loading... |
3350 switch (getValueID()) { | 3350 switch (getValueID()) { |
3351 case CSSValueNone: | 3351 case CSSValueNone: |
3352 return ScrollSnapTypeNone; | 3352 return ScrollSnapTypeNone; |
3353 case CSSValueMandatory: | 3353 case CSSValueMandatory: |
3354 return ScrollSnapTypeMandatory; | 3354 return ScrollSnapTypeMandatory; |
3355 case CSSValueProximity: | 3355 case CSSValueProximity: |
3356 return ScrollSnapTypeProximity; | 3356 return ScrollSnapTypeProximity; |
3357 default: | 3357 default: |
3358 break; | 3358 break; |
3359 } | 3359 } |
3360 ASSERT_NOT_REACHED(); | 3360 NOTREACHED(); |
3361 return ScrollSnapTypeNone; | 3361 return ScrollSnapTypeNone; |
3362 } | 3362 } |
3363 | 3363 |
3364 template <> | 3364 template <> |
3365 inline CSSIdentifierValue::CSSIdentifierValue(Containment snapType) | 3365 inline CSSIdentifierValue::CSSIdentifierValue(Containment snapType) |
3366 : CSSValue(IdentifierClass) { | 3366 : CSSValue(IdentifierClass) { |
3367 switch (snapType) { | 3367 switch (snapType) { |
3368 case ContainsNone: | 3368 case ContainsNone: |
3369 m_valueID = CSSValueNone; | 3369 m_valueID = CSSValueNone; |
3370 break; | 3370 break; |
(...skipping 31 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3402 return ContainsPaint; | 3402 return ContainsPaint; |
3403 case CSSValueStyle: | 3403 case CSSValueStyle: |
3404 return ContainsStyle; | 3404 return ContainsStyle; |
3405 case CSSValueLayout: | 3405 case CSSValueLayout: |
3406 return ContainsLayout; | 3406 return ContainsLayout; |
3407 case CSSValueSize: | 3407 case CSSValueSize: |
3408 return ContainsSize; | 3408 return ContainsSize; |
3409 default: | 3409 default: |
3410 break; | 3410 break; |
3411 } | 3411 } |
3412 ASSERT_NOT_REACHED(); | 3412 NOTREACHED(); |
3413 return ContainsNone; | 3413 return ContainsNone; |
3414 } | 3414 } |
3415 | 3415 |
3416 } // namespace blink | 3416 } // namespace blink |
3417 | 3417 |
3418 #endif | 3418 #endif |
OLD | NEW |