Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(16)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: third_party/WebKit/Source/core/css/CSSPrimitiveValueMappings.h

Issue 2346193002: Split CSSPrimitiveValue into CSSPrimitiveValue and CSSIdentifierValue (Closed)
Patch Set: Rebase please work Created 4 years, 3 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « third_party/WebKit/Source/core/css/CSSPrimitiveValue.cpp ('k') | third_party/WebKit/Source/core/css/CSSQuadValue.h » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: third_party/WebKit/Source/core/css/CSSPrimitiveValueMappings.h
diff --git a/third_party/WebKit/Source/core/css/CSSPrimitiveValueMappings.h b/third_party/WebKit/Source/core/css/CSSPrimitiveValueMappings.h
index 33e1795472c206e786d19a1357d56f078c4c2c1a..be28bf9d48cb011e6444f2a6056eb5734a007b74 100644
--- a/third_party/WebKit/Source/core/css/CSSPrimitiveValueMappings.h
+++ b/third_party/WebKit/Source/core/css/CSSPrimitiveValueMappings.h
@@ -32,12 +32,13 @@
#include "core/CSSValueKeywords.h"
#include "core/css/CSSCalculationValue.h"
+#include "core/css/CSSIdentifierValue.h"
#include "core/css/CSSPrimitiveValue.h"
#include "core/css/CSSReflectionDirection.h"
#include "core/css/CSSToLengthConversionData.h"
#include "core/style/ComputedStyleConstants.h"
-#include "core/style/SVGComputedStyleDefs.h"
#include "core/style/LineClampValue.h"
+#include "core/style/SVGComputedStyleDefs.h"
#include "platform/Length.h"
#include "platform/ThemeTypes.h"
#include "platform/fonts/FontDescription.h"
@@ -54,6 +55,7 @@
namespace blink {
+// TODO(sashab): Move these to CSSPrimitiveValue.h.
template<> inline short CSSPrimitiveValue::convertTo() const
{
ASSERT(isNumber());
@@ -103,29 +105,29 @@ template<> inline LineClampValue CSSPrimitiveValue::convertTo() const
return LineClampValue();
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(CSSReflectionDirection e)
- : CSSValue(PrimitiveClass)
+// TODO(sashab): Move these to CSSIdentifierValueMappings.h, and update to use
+// the CSSValuePool.
+template<> inline CSSIdentifierValue::CSSIdentifierValue(CSSReflectionDirection e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
case ReflectionAbove:
- m_value.valueID = CSSValueAbove;
+ m_valueID = CSSValueAbove;
break;
case ReflectionBelow:
- m_value.valueID = CSSValueBelow;
+ m_valueID = CSSValueBelow;
break;
case ReflectionLeft:
- m_value.valueID = CSSValueLeft;
+ m_valueID = CSSValueLeft;
break;
case ReflectionRight:
- m_value.valueID = CSSValueRight;
+ m_valueID = CSSValueRight;
}
}
-template<> inline CSSReflectionDirection CSSPrimitiveValue::convertTo() const
+template<> inline CSSReflectionDirection CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueAbove:
return ReflectionAbove;
case CSSValueBelow:
@@ -142,50 +144,45 @@ template<> inline CSSReflectionDirection CSSPrimitiveValue::convertTo() const
return ReflectionBelow;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ColumnFill columnFill)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(ColumnFill columnFill)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (columnFill) {
case ColumnFillAuto:
- m_value.valueID = CSSValueAuto;
+ m_valueID = CSSValueAuto;
break;
case ColumnFillBalance:
- m_value.valueID = CSSValueBalance;
+ m_valueID = CSSValueBalance;
break;
}
}
-template<> inline ColumnFill CSSPrimitiveValue::convertTo() const
+template<> inline ColumnFill CSSIdentifierValue::convertTo() const
{
- if (type() == UnitType::ValueID) {
- if (m_value.valueID == CSSValueBalance)
- return ColumnFillBalance;
- if (m_value.valueID == CSSValueAuto)
- return ColumnFillAuto;
- }
+ if (m_valueID == CSSValueBalance)
+ return ColumnFillBalance;
+ if (m_valueID == CSSValueAuto)
+ return ColumnFillAuto;
ASSERT_NOT_REACHED();
return ColumnFillBalance;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ColumnSpan columnSpan)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(ColumnSpan columnSpan)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (columnSpan) {
case ColumnSpanAll:
- m_value.valueID = CSSValueAll;
+ m_valueID = CSSValueAll;
break;
case ColumnSpanNone:
- m_value.valueID = CSSValueNone;
+ m_valueID = CSSValueNone;
break;
}
}
-template<> inline ColumnSpan CSSPrimitiveValue::convertTo() const
+template<> inline ColumnSpan CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueAll:
return ColumnSpanAll;
default:
@@ -197,24 +194,22 @@ template<> inline ColumnSpan CSSPrimitiveValue::convertTo() const
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(PrintColorAdjust value)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(PrintColorAdjust value)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (value) {
case PrintColorAdjustExact:
- m_value.valueID = CSSValueExact;
+ m_valueID = CSSValueExact;
break;
case PrintColorAdjustEconomy:
- m_value.valueID = CSSValueEconomy;
+ m_valueID = CSSValueEconomy;
break;
}
}
-template<> inline PrintColorAdjust CSSPrimitiveValue::convertTo() const
+template<> inline PrintColorAdjust CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueEconomy:
return PrintColorAdjustEconomy;
case CSSValueExact:
@@ -228,99 +223,96 @@ template<> inline PrintColorAdjust CSSPrimitiveValue::convertTo() const
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBorderStyle e)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(EBorderStyle e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
case BorderStyleNone:
- m_value.valueID = CSSValueNone;
+ m_valueID = CSSValueNone;
break;
case BorderStyleHidden:
- m_value.valueID = CSSValueHidden;
+ m_valueID = CSSValueHidden;
break;
case BorderStyleInset:
- m_value.valueID = CSSValueInset;
+ m_valueID = CSSValueInset;
break;
case BorderStyleGroove:
- m_value.valueID = CSSValueGroove;
+ m_valueID = CSSValueGroove;
break;
case BorderStyleRidge:
- m_value.valueID = CSSValueRidge;
+ m_valueID = CSSValueRidge;
break;
case BorderStyleOutset:
- m_value.valueID = CSSValueOutset;
+ m_valueID = CSSValueOutset;
break;
case BorderStyleDotted:
- m_value.valueID = CSSValueDotted;
+ m_valueID = CSSValueDotted;
break;
case BorderStyleDashed:
- m_value.valueID = CSSValueDashed;
+ m_valueID = CSSValueDashed;
break;
case BorderStyleSolid:
- m_value.valueID = CSSValueSolid;
+ m_valueID = CSSValueSolid;
break;
case BorderStyleDouble:
- m_value.valueID = CSSValueDouble;
+ m_valueID = CSSValueDouble;
break;
}
}
-template<> inline EBorderStyle CSSPrimitiveValue::convertTo() const
+template<> inline EBorderStyle CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- if (m_value.valueID == CSSValueAuto) // Valid for CSS outline-style
+ if (m_valueID == CSSValueAuto) // Valid for CSS outline-style
return BorderStyleDotted;
- return (EBorderStyle)(m_value.valueID - CSSValueNone);
+ return (EBorderStyle)(m_valueID - CSSValueNone);
}
-template<> inline OutlineIsAuto CSSPrimitiveValue::convertTo() const
+template<> inline OutlineIsAuto CSSIdentifierValue::convertTo() const
{
- if (m_value.valueID == CSSValueAuto)
+ if (m_valueID == CSSValueAuto)
return OutlineIsAutoOn;
return OutlineIsAutoOff;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(CompositeOperator e)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(CompositeOperator e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
case CompositeClear:
- m_value.valueID = CSSValueClear;
+ m_valueID = CSSValueClear;
break;
case CompositeCopy:
- m_value.valueID = CSSValueCopy;
+ m_valueID = CSSValueCopy;
break;
case CompositeSourceOver:
- m_value.valueID = CSSValueSourceOver;
+ m_valueID = CSSValueSourceOver;
break;
case CompositeSourceIn:
- m_value.valueID = CSSValueSourceIn;
+ m_valueID = CSSValueSourceIn;
break;
case CompositeSourceOut:
- m_value.valueID = CSSValueSourceOut;
+ m_valueID = CSSValueSourceOut;
break;
case CompositeSourceAtop:
- m_value.valueID = CSSValueSourceAtop;
+ m_valueID = CSSValueSourceAtop;
break;
case CompositeDestinationOver:
- m_value.valueID = CSSValueDestinationOver;
+ m_valueID = CSSValueDestinationOver;
break;
case CompositeDestinationIn:
- m_value.valueID = CSSValueDestinationIn;
+ m_valueID = CSSValueDestinationIn;
break;
case CompositeDestinationOut:
- m_value.valueID = CSSValueDestinationOut;
+ m_valueID = CSSValueDestinationOut;
break;
case CompositeDestinationAtop:
- m_value.valueID = CSSValueDestinationAtop;
+ m_valueID = CSSValueDestinationAtop;
break;
case CompositeXOR:
- m_value.valueID = CSSValueXor;
+ m_valueID = CSSValueXor;
break;
case CompositePlusLighter:
- m_value.valueID = CSSValuePlusLighter;
+ m_valueID = CSSValuePlusLighter;
break;
default:
ASSERT_NOT_REACHED();
@@ -328,10 +320,9 @@ template<> inline CSSPrimitiveValue::CSSPrimitiveValue(CompositeOperator e)
}
}
-template<> inline CompositeOperator CSSPrimitiveValue::convertTo() const
+template<> inline CompositeOperator CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueClear:
return CompositeClear;
case CSSValueCopy:
@@ -364,193 +355,189 @@ template<> inline CompositeOperator CSSPrimitiveValue::convertTo() const
return CompositeClear;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ControlPart e)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(ControlPart e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
case NoControlPart:
- m_value.valueID = CSSValueNone;
+ m_valueID = CSSValueNone;
break;
case CheckboxPart:
- m_value.valueID = CSSValueCheckbox;
+ m_valueID = CSSValueCheckbox;
break;
case RadioPart:
- m_value.valueID = CSSValueRadio;
+ m_valueID = CSSValueRadio;
break;
case PushButtonPart:
- m_value.valueID = CSSValuePushButton;
+ m_valueID = CSSValuePushButton;
break;
case SquareButtonPart:
- m_value.valueID = CSSValueSquareButton;
+ m_valueID = CSSValueSquareButton;
break;
case ButtonPart:
- m_value.valueID = CSSValueButton;
+ m_valueID = CSSValueButton;
break;
case ButtonBevelPart:
- m_value.valueID = CSSValueButtonBevel;
+ m_valueID = CSSValueButtonBevel;
break;
case InnerSpinButtonPart:
- m_value.valueID = CSSValueInnerSpinButton;
+ m_valueID = CSSValueInnerSpinButton;
break;
case ListboxPart:
- m_value.valueID = CSSValueListbox;
+ m_valueID = CSSValueListbox;
break;
case ListItemPart:
- m_value.valueID = CSSValueListitem;
+ m_valueID = CSSValueListitem;
break;
case MediaEnterFullscreenButtonPart:
- m_value.valueID = CSSValueMediaEnterFullscreenButton;
+ m_valueID = CSSValueMediaEnterFullscreenButton;
break;
case MediaExitFullscreenButtonPart:
- m_value.valueID = CSSValueMediaExitFullscreenButton;
+ m_valueID = CSSValueMediaExitFullscreenButton;
break;
case MediaPlayButtonPart:
- m_value.valueID = CSSValueMediaPlayButton;
+ m_valueID = CSSValueMediaPlayButton;
break;
case MediaOverlayPlayButtonPart:
- m_value.valueID = CSSValueMediaOverlayPlayButton;
+ m_valueID = CSSValueMediaOverlayPlayButton;
break;
case MediaMuteButtonPart:
- m_value.valueID = CSSValueMediaMuteButton;
+ m_valueID = CSSValueMediaMuteButton;
break;
case MediaToggleClosedCaptionsButtonPart:
- m_value.valueID = CSSValueMediaToggleClosedCaptionsButton;
+ m_valueID = CSSValueMediaToggleClosedCaptionsButton;
break;
case MediaCastOffButtonPart:
- m_value.valueID = CSSValueInternalMediaCastOffButton;
+ m_valueID = CSSValueInternalMediaCastOffButton;
break;
case MediaOverlayCastOffButtonPart:
- m_value.valueID = CSSValueInternalMediaOverlayCastOffButton;
+ m_valueID = CSSValueInternalMediaOverlayCastOffButton;
break;
case MediaSliderPart:
- m_value.valueID = CSSValueMediaSlider;
+ m_valueID = CSSValueMediaSlider;
break;
case MediaSliderThumbPart:
- m_value.valueID = CSSValueMediaSliderthumb;
+ m_valueID = CSSValueMediaSliderthumb;
break;
case MediaVolumeSliderContainerPart:
- m_value.valueID = CSSValueMediaVolumeSliderContainer;
+ m_valueID = CSSValueMediaVolumeSliderContainer;
break;
case MediaVolumeSliderPart:
- m_value.valueID = CSSValueMediaVolumeSlider;
+ m_valueID = CSSValueMediaVolumeSlider;
break;
case MediaVolumeSliderThumbPart:
- m_value.valueID = CSSValueMediaVolumeSliderthumb;
+ m_valueID = CSSValueMediaVolumeSliderthumb;
break;
case MediaControlsBackgroundPart:
- m_value.valueID = CSSValueMediaControlsBackground;
+ m_valueID = CSSValueMediaControlsBackground;
break;
case MediaControlsFullscreenBackgroundPart:
- m_value.valueID = CSSValueMediaControlsFullscreenBackground;
+ m_valueID = CSSValueMediaControlsFullscreenBackground;
break;
case MediaFullscreenVolumeSliderPart:
- m_value.valueID = CSSValueMediaFullscreenVolumeSlider;
+ m_valueID = CSSValueMediaFullscreenVolumeSlider;
break;
case MediaFullscreenVolumeSliderThumbPart:
- m_value.valueID = CSSValueMediaFullscreenVolumeSliderThumb;
+ m_valueID = CSSValueMediaFullscreenVolumeSliderThumb;
break;
case MediaCurrentTimePart:
- m_value.valueID = CSSValueMediaCurrentTimeDisplay;
+ m_valueID = CSSValueMediaCurrentTimeDisplay;
break;
case MediaTimeRemainingPart:
- m_value.valueID = CSSValueMediaTimeRemainingDisplay;
+ m_valueID = CSSValueMediaTimeRemainingDisplay;
break;
case MediaTrackSelectionCheckmarkPart:
- m_value.valueID = CSSValueInternalMediaTrackSelectionCheckmark;
+ m_valueID = CSSValueInternalMediaTrackSelectionCheckmark;
break;
case MediaClosedCaptionsIconPart:
- m_value.valueID = CSSValueInternalMediaClosedCaptionsIcon;
+ m_valueID = CSSValueInternalMediaClosedCaptionsIcon;
break;
case MediaSubtitlesIconPart:
- m_value.valueID = CSSValueInternalMediaSubtitlesIcon;
+ m_valueID = CSSValueInternalMediaSubtitlesIcon;
break;
case MediaOverflowMenuButtonPart:
- m_value.valueID = CSSValueInternalMediaOverflowButton;
+ m_valueID = CSSValueInternalMediaOverflowButton;
break;
case MediaDownloadIconPart:
- m_value.valueID = CSSValueInternalMediaDownloadButton;
+ m_valueID = CSSValueInternalMediaDownloadButton;
break;
case MenulistPart:
- m_value.valueID = CSSValueMenulist;
+ m_valueID = CSSValueMenulist;
break;
case MenulistButtonPart:
- m_value.valueID = CSSValueMenulistButton;
+ m_valueID = CSSValueMenulistButton;
break;
case MenulistTextPart:
- m_value.valueID = CSSValueMenulistText;
+ m_valueID = CSSValueMenulistText;
break;
case MenulistTextFieldPart:
- m_value.valueID = CSSValueMenulistTextfield;
+ m_valueID = CSSValueMenulistTextfield;
break;
case MeterPart:
- m_value.valueID = CSSValueMeter;
+ m_valueID = CSSValueMeter;
break;
case ProgressBarPart:
- m_value.valueID = CSSValueProgressBar;
+ m_valueID = CSSValueProgressBar;
break;
case ProgressBarValuePart:
- m_value.valueID = CSSValueProgressBarValue;
+ m_valueID = CSSValueProgressBarValue;
break;
case SliderHorizontalPart:
- m_value.valueID = CSSValueSliderHorizontal;
+ m_valueID = CSSValueSliderHorizontal;
break;
case SliderVerticalPart:
- m_value.valueID = CSSValueSliderVertical;
+ m_valueID = CSSValueSliderVertical;
break;
case SliderThumbHorizontalPart:
- m_value.valueID = CSSValueSliderthumbHorizontal;
+ m_valueID = CSSValueSliderthumbHorizontal;
break;
case SliderThumbVerticalPart:
- m_value.valueID = CSSValueSliderthumbVertical;
+ m_valueID = CSSValueSliderthumbVertical;
break;
case CaretPart:
- m_value.valueID = CSSValueCaret;
+ m_valueID = CSSValueCaret;
break;
case SearchFieldPart:
- m_value.valueID = CSSValueSearchfield;
+ m_valueID = CSSValueSearchfield;
break;
case SearchFieldCancelButtonPart:
- m_value.valueID = CSSValueSearchfieldCancelButton;
+ m_valueID = CSSValueSearchfieldCancelButton;
break;
case TextFieldPart:
- m_value.valueID = CSSValueTextfield;
+ m_valueID = CSSValueTextfield;
break;
case TextAreaPart:
- m_value.valueID = CSSValueTextarea;
+ m_valueID = CSSValueTextarea;
break;
case CapsLockIndicatorPart:
- m_value.valueID = CSSValueCapsLockIndicator;
+ m_valueID = CSSValueCapsLockIndicator;
break;
}
}
-template<> inline ControlPart CSSPrimitiveValue::convertTo() const
+template<> inline ControlPart CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- if (m_value.valueID == CSSValueNone)
+ if (m_valueID == CSSValueNone)
return NoControlPart;
- return ControlPart(m_value.valueID - CSSValueCheckbox + 1);
+ return ControlPart(m_valueID - CSSValueCheckbox + 1);
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBackfaceVisibility e)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(EBackfaceVisibility e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
case BackfaceVisibilityVisible:
- m_value.valueID = CSSValueVisible;
+ m_valueID = CSSValueVisible;
break;
case BackfaceVisibilityHidden:
- m_value.valueID = CSSValueHidden;
+ m_valueID = CSSValueHidden;
break;
}
}
-template<> inline EBackfaceVisibility CSSPrimitiveValue::convertTo() const
+template<> inline EBackfaceVisibility CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueVisible:
return BackfaceVisibilityVisible;
case CSSValueHidden:
@@ -564,27 +551,25 @@ template<> inline EBackfaceVisibility CSSPrimitiveValue::convertTo() const
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFillAttachment e)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(EFillAttachment e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
case ScrollBackgroundAttachment:
- m_value.valueID = CSSValueScroll;
+ m_valueID = CSSValueScroll;
break;
case LocalBackgroundAttachment:
- m_value.valueID = CSSValueLocal;
+ m_valueID = CSSValueLocal;
break;
case FixedBackgroundAttachment:
- m_value.valueID = CSSValueFixed;
+ m_valueID = CSSValueFixed;
break;
}
}
-template<> inline EFillAttachment CSSPrimitiveValue::convertTo() const
+template<> inline EFillAttachment CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueScroll:
return ScrollBackgroundAttachment;
case CSSValueLocal:
@@ -599,30 +584,28 @@ template<> inline EFillAttachment CSSPrimitiveValue::convertTo() const
return ScrollBackgroundAttachment;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFillBox e)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(EFillBox e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
case BorderFillBox:
- m_value.valueID = CSSValueBorderBox;
+ m_valueID = CSSValueBorderBox;
break;
case PaddingFillBox:
- m_value.valueID = CSSValuePaddingBox;
+ m_valueID = CSSValuePaddingBox;
break;
case ContentFillBox:
- m_value.valueID = CSSValueContentBox;
+ m_valueID = CSSValueContentBox;
break;
case TextFillBox:
- m_value.valueID = CSSValueText;
+ m_valueID = CSSValueText;
break;
}
}
-template<> inline EFillBox CSSPrimitiveValue::convertTo() const
+template<> inline EFillBox CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueBorder:
case CSSValueBorderBox:
return BorderFillBox;
@@ -642,30 +625,28 @@ template<> inline EFillBox CSSPrimitiveValue::convertTo() const
return BorderFillBox;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFillRepeat e)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(EFillRepeat e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
case RepeatFill:
- m_value.valueID = CSSValueRepeat;
+ m_valueID = CSSValueRepeat;
break;
case NoRepeatFill:
- m_value.valueID = CSSValueNoRepeat;
+ m_valueID = CSSValueNoRepeat;
break;
case RoundFill:
- m_value.valueID = CSSValueRound;
+ m_valueID = CSSValueRound;
break;
case SpaceFill:
- m_value.valueID = CSSValueSpace;
+ m_valueID = CSSValueSpace;
break;
}
}
-template<> inline EFillRepeat CSSPrimitiveValue::convertTo() const
+template<> inline EFillRepeat CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueRepeat:
return RepeatFill;
case CSSValueNoRepeat:
@@ -682,30 +663,28 @@ template<> inline EFillRepeat CSSPrimitiveValue::convertTo() const
return RepeatFill;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxPack e)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(EBoxPack e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
case BoxPackStart:
- m_value.valueID = CSSValueStart;
+ m_valueID = CSSValueStart;
break;
case BoxPackCenter:
- m_value.valueID = CSSValueCenter;
+ m_valueID = CSSValueCenter;
break;
case BoxPackEnd:
- m_value.valueID = CSSValueEnd;
+ m_valueID = CSSValueEnd;
break;
case BoxPackJustify:
- m_value.valueID = CSSValueJustify;
+ m_valueID = CSSValueJustify;
break;
}
}
-template<> inline EBoxPack CSSPrimitiveValue::convertTo() const
+template<> inline EBoxPack CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueStart:
return BoxPackStart;
case CSSValueEnd:
@@ -722,33 +701,31 @@ template<> inline EBoxPack CSSPrimitiveValue::convertTo() const
return BoxPackJustify;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxAlignment e)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(EBoxAlignment e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
case BSTRETCH:
- m_value.valueID = CSSValueStretch;
+ m_valueID = CSSValueStretch;
break;
case BSTART:
- m_value.valueID = CSSValueStart;
+ m_valueID = CSSValueStart;
break;
case BCENTER:
- m_value.valueID = CSSValueCenter;
+ m_valueID = CSSValueCenter;
break;
case BEND:
- m_value.valueID = CSSValueEnd;
+ m_valueID = CSSValueEnd;
break;
case BBASELINE:
- m_value.valueID = CSSValueBaseline;
+ m_valueID = CSSValueBaseline;
break;
}
}
-template<> inline EBoxAlignment CSSPrimitiveValue::convertTo() const
+template<> inline EBoxAlignment CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueStretch:
return BSTRETCH;
case CSSValueStart:
@@ -767,24 +744,22 @@ template<> inline EBoxAlignment CSSPrimitiveValue::convertTo() const
return BSTRETCH;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxDecorationBreak e)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(EBoxDecorationBreak e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
case BoxDecorationBreakSlice:
- m_value.valueID = CSSValueSlice;
+ m_valueID = CSSValueSlice;
break;
case BoxDecorationBreakClone:
- m_value.valueID = CSSValueClone;
+ m_valueID = CSSValueClone;
break;
}
}
-template<> inline EBoxDecorationBreak CSSPrimitiveValue::convertTo() const
+template<> inline EBoxDecorationBreak CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueSlice:
return BoxDecorationBreakSlice;
case CSSValueClone:
@@ -797,30 +772,28 @@ template<> inline EBoxDecorationBreak CSSPrimitiveValue::convertTo() const
return BoxDecorationBreakSlice;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(BackgroundEdgeOrigin e)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(BackgroundEdgeOrigin e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
case TopEdge:
- m_value.valueID = CSSValueTop;
+ m_valueID = CSSValueTop;
break;
case RightEdge:
- m_value.valueID = CSSValueRight;
+ m_valueID = CSSValueRight;
break;
case BottomEdge:
- m_value.valueID = CSSValueBottom;
+ m_valueID = CSSValueBottom;
break;
case LeftEdge:
- m_value.valueID = CSSValueLeft;
+ m_valueID = CSSValueLeft;
break;
}
}
-template<> inline BackgroundEdgeOrigin CSSPrimitiveValue::convertTo() const
+template<> inline BackgroundEdgeOrigin CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueTop:
return TopEdge;
case CSSValueRight:
@@ -837,24 +810,22 @@ template<> inline BackgroundEdgeOrigin CSSPrimitiveValue::convertTo() const
return TopEdge;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxSizing e)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(EBoxSizing e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
case BoxSizingBorderBox:
- m_value.valueID = CSSValueBorderBox;
+ m_valueID = CSSValueBorderBox;
break;
case BoxSizingContentBox:
- m_value.valueID = CSSValueContentBox;
+ m_valueID = CSSValueContentBox;
break;
}
}
-template<> inline EBoxSizing CSSPrimitiveValue::convertTo() const
+template<> inline EBoxSizing CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueBorderBox:
return BoxSizingBorderBox;
case CSSValueContentBox:
@@ -867,24 +838,22 @@ template<> inline EBoxSizing CSSPrimitiveValue::convertTo() const
return BoxSizingBorderBox;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxDirection e)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(EBoxDirection e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
case BNORMAL:
- m_value.valueID = CSSValueNormal;
+ m_valueID = CSSValueNormal;
break;
case BREVERSE:
- m_value.valueID = CSSValueReverse;
+ m_valueID = CSSValueReverse;
break;
}
}
-template<> inline EBoxDirection CSSPrimitiveValue::convertTo() const
+template<> inline EBoxDirection CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueNormal:
return BNORMAL;
case CSSValueReverse:
@@ -897,24 +866,22 @@ template<> inline EBoxDirection CSSPrimitiveValue::convertTo() const
return BNORMAL;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxLines e)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(EBoxLines e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
case SINGLE:
- m_value.valueID = CSSValueSingle;
+ m_valueID = CSSValueSingle;
break;
case MULTIPLE:
- m_value.valueID = CSSValueMultiple;
+ m_valueID = CSSValueMultiple;
break;
}
}
-template<> inline EBoxLines CSSPrimitiveValue::convertTo() const
+template<> inline EBoxLines CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueSingle:
return SINGLE;
case CSSValueMultiple:
@@ -927,24 +894,22 @@ template<> inline EBoxLines CSSPrimitiveValue::convertTo() const
return SINGLE;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxOrient e)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(EBoxOrient e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
case HORIZONTAL:
- m_value.valueID = CSSValueHorizontal;
+ m_valueID = CSSValueHorizontal;
break;
case VERTICAL:
- m_value.valueID = CSSValueVertical;
+ m_valueID = CSSValueVertical;
break;
}
}
-template<> inline EBoxOrient CSSPrimitiveValue::convertTo() const
+template<> inline EBoxOrient CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueHorizontal:
case CSSValueInlineAxis:
return HORIZONTAL;
@@ -959,30 +924,28 @@ template<> inline EBoxOrient CSSPrimitiveValue::convertTo() const
return HORIZONTAL;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ECaptionSide e)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(ECaptionSide e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
case ECaptionSide::Left:
- m_value.valueID = CSSValueLeft;
+ m_valueID = CSSValueLeft;
break;
case ECaptionSide::Right:
- m_value.valueID = CSSValueRight;
+ m_valueID = CSSValueRight;
break;
case ECaptionSide::Top:
- m_value.valueID = CSSValueTop;
+ m_valueID = CSSValueTop;
break;
case ECaptionSide::Bottom:
- m_value.valueID = CSSValueBottom;
+ m_valueID = CSSValueBottom;
break;
}
}
-template<> inline ECaptionSide CSSPrimitiveValue::convertTo() const
+template<> inline ECaptionSide CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueLeft:
return ECaptionSide::Left;
case CSSValueRight:
@@ -999,30 +962,28 @@ template<> inline ECaptionSide CSSPrimitiveValue::convertTo() const
return ECaptionSide::Top;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EClear e)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(EClear e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
case ClearNone:
- m_value.valueID = CSSValueNone;
+ m_valueID = CSSValueNone;
break;
case ClearLeft:
- m_value.valueID = CSSValueLeft;
+ m_valueID = CSSValueLeft;
break;
case ClearRight:
- m_value.valueID = CSSValueRight;
+ m_valueID = CSSValueRight;
break;
case ClearBoth:
- m_value.valueID = CSSValueBoth;
+ m_valueID = CSSValueBoth;
break;
}
}
-template<> inline EClear CSSPrimitiveValue::convertTo() const
+template<> inline EClear CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueNone:
return ClearNone;
case CSSValueLeft:
@@ -1039,126 +1000,124 @@ template<> inline EClear CSSPrimitiveValue::convertTo() const
return ClearNone;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ECursor e)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(ECursor e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
case CURSOR_AUTO:
- m_value.valueID = CSSValueAuto;
+ m_valueID = CSSValueAuto;
break;
case CURSOR_CROSS:
- m_value.valueID = CSSValueCrosshair;
+ m_valueID = CSSValueCrosshair;
break;
case CURSOR_DEFAULT:
- m_value.valueID = CSSValueDefault;
+ m_valueID = CSSValueDefault;
break;
case CURSOR_POINTER:
- m_value.valueID = CSSValuePointer;
+ m_valueID = CSSValuePointer;
break;
case CURSOR_MOVE:
- m_value.valueID = CSSValueMove;
+ m_valueID = CSSValueMove;
break;
case CURSOR_CELL:
- m_value.valueID = CSSValueCell;
+ m_valueID = CSSValueCell;
break;
case CURSOR_VERTICAL_TEXT:
- m_value.valueID = CSSValueVerticalText;
+ m_valueID = CSSValueVerticalText;
break;
case CURSOR_CONTEXT_MENU:
- m_value.valueID = CSSValueContextMenu;
+ m_valueID = CSSValueContextMenu;
break;
case CURSOR_ALIAS:
- m_value.valueID = CSSValueAlias;
+ m_valueID = CSSValueAlias;
break;
case CURSOR_COPY:
- m_value.valueID = CSSValueCopy;
+ m_valueID = CSSValueCopy;
break;
case CURSOR_NONE:
- m_value.valueID = CSSValueNone;
+ m_valueID = CSSValueNone;
break;
case CURSOR_PROGRESS:
- m_value.valueID = CSSValueProgress;
+ m_valueID = CSSValueProgress;
break;
case CURSOR_NO_DROP:
- m_value.valueID = CSSValueNoDrop;
+ m_valueID = CSSValueNoDrop;
break;
case CURSOR_NOT_ALLOWED:
- m_value.valueID = CSSValueNotAllowed;
+ m_valueID = CSSValueNotAllowed;
break;
case CURSOR_ZOOM_IN:
- m_value.valueID = CSSValueZoomIn;
+ m_valueID = CSSValueZoomIn;
break;
case CURSOR_ZOOM_OUT:
- m_value.valueID = CSSValueZoomOut;
+ m_valueID = CSSValueZoomOut;
break;
case CURSOR_E_RESIZE:
- m_value.valueID = CSSValueEResize;
+ m_valueID = CSSValueEResize;
break;
case CURSOR_NE_RESIZE:
- m_value.valueID = CSSValueNeResize;
+ m_valueID = CSSValueNeResize;
break;
case CURSOR_NW_RESIZE:
- m_value.valueID = CSSValueNwResize;
+ m_valueID = CSSValueNwResize;
break;
case CURSOR_N_RESIZE:
- m_value.valueID = CSSValueNResize;
+ m_valueID = CSSValueNResize;
break;
case CURSOR_SE_RESIZE:
- m_value.valueID = CSSValueSeResize;
+ m_valueID = CSSValueSeResize;
break;
case CURSOR_SW_RESIZE:
- m_value.valueID = CSSValueSwResize;
+ m_valueID = CSSValueSwResize;
break;
case CURSOR_S_RESIZE:
- m_value.valueID = CSSValueSResize;
+ m_valueID = CSSValueSResize;
break;
case CURSOR_W_RESIZE:
- m_value.valueID = CSSValueWResize;
+ m_valueID = CSSValueWResize;
break;
case CURSOR_EW_RESIZE:
- m_value.valueID = CSSValueEwResize;
+ m_valueID = CSSValueEwResize;
break;
case CURSOR_NS_RESIZE:
- m_value.valueID = CSSValueNsResize;
+ m_valueID = CSSValueNsResize;
break;
case CURSOR_NESW_RESIZE:
- m_value.valueID = CSSValueNeswResize;
+ m_valueID = CSSValueNeswResize;
break;
case CURSOR_NWSE_RESIZE:
- m_value.valueID = CSSValueNwseResize;
+ m_valueID = CSSValueNwseResize;
break;
case CURSOR_COL_RESIZE:
- m_value.valueID = CSSValueColResize;
+ m_valueID = CSSValueColResize;
break;
case CURSOR_ROW_RESIZE:
- m_value.valueID = CSSValueRowResize;
+ m_valueID = CSSValueRowResize;
break;
case CURSOR_TEXT:
- m_value.valueID = CSSValueText;
+ m_valueID = CSSValueText;
break;
case CURSOR_WAIT:
- m_value.valueID = CSSValueWait;
+ m_valueID = CSSValueWait;
break;
case CURSOR_HELP:
- m_value.valueID = CSSValueHelp;
+ m_valueID = CSSValueHelp;
break;
case CURSOR_ALL_SCROLL:
- m_value.valueID = CSSValueAllScroll;
+ m_valueID = CSSValueAllScroll;
break;
case CURSOR_WEBKIT_GRAB:
- m_value.valueID = CSSValueWebkitGrab;
+ m_valueID = CSSValueWebkitGrab;
break;
case CURSOR_WEBKIT_GRABBING:
- m_value.valueID = CSSValueWebkitGrabbing;
+ m_valueID = CSSValueWebkitGrabbing;
break;
}
}
-template<> inline ECursor CSSPrimitiveValue::convertTo() const
+template<> inline ECursor CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueCopy:
return CURSOR_COPY;
case CSSValueWebkitZoomIn:
@@ -1168,115 +1127,111 @@ template<> inline ECursor CSSPrimitiveValue::convertTo() const
case CSSValueNone:
return CURSOR_NONE;
default:
- return static_cast<ECursor>(m_value.valueID - CSSValueAuto);
+ return static_cast<ECursor>(m_valueID - CSSValueAuto);
}
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EDisplay e)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(EDisplay e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
case EDisplay::Inline:
- m_value.valueID = CSSValueInline;
+ m_valueID = CSSValueInline;
break;
case EDisplay::Block:
- m_value.valueID = CSSValueBlock;
+ m_valueID = CSSValueBlock;
break;
case EDisplay::ListItem:
- m_value.valueID = CSSValueListItem;
+ m_valueID = CSSValueListItem;
break;
case EDisplay::InlineBlock:
- m_value.valueID = CSSValueInlineBlock;
+ m_valueID = CSSValueInlineBlock;
break;
case EDisplay::Table:
- m_value.valueID = CSSValueTable;
+ m_valueID = CSSValueTable;
break;
case EDisplay::InlineTable:
- m_value.valueID = CSSValueInlineTable;
+ m_valueID = CSSValueInlineTable;
break;
case EDisplay::TableRowGroup:
- m_value.valueID = CSSValueTableRowGroup;
+ m_valueID = CSSValueTableRowGroup;
break;
case EDisplay::TableHeaderGroup:
- m_value.valueID = CSSValueTableHeaderGroup;
+ m_valueID = CSSValueTableHeaderGroup;
break;
case EDisplay::TableFooterGroup:
- m_value.valueID = CSSValueTableFooterGroup;
+ m_valueID = CSSValueTableFooterGroup;
break;
case EDisplay::TableRow:
- m_value.valueID = CSSValueTableRow;
+ m_valueID = CSSValueTableRow;
break;
case EDisplay::TableColumnGroup:
- m_value.valueID = CSSValueTableColumnGroup;
+ m_valueID = CSSValueTableColumnGroup;
break;
case EDisplay::TableColumn:
- m_value.valueID = CSSValueTableColumn;
+ m_valueID = CSSValueTableColumn;
break;
case EDisplay::TableCell:
- m_value.valueID = CSSValueTableCell;
+ m_valueID = CSSValueTableCell;
break;
case EDisplay::TableCaption:
- m_value.valueID = CSSValueTableCaption;
+ m_valueID = CSSValueTableCaption;
break;
case EDisplay::Box:
- m_value.valueID = CSSValueWebkitBox;
+ m_valueID = CSSValueWebkitBox;
break;
case EDisplay::InlineBox:
- m_value.valueID = CSSValueWebkitInlineBox;
+ m_valueID = CSSValueWebkitInlineBox;
break;
case EDisplay::Flex:
- m_value.valueID = CSSValueFlex;
+ m_valueID = CSSValueFlex;
break;
case EDisplay::InlineFlex:
- m_value.valueID = CSSValueInlineFlex;
+ m_valueID = CSSValueInlineFlex;
break;
case EDisplay::Grid:
- m_value.valueID = CSSValueGrid;
+ m_valueID = CSSValueGrid;
break;
case EDisplay::InlineGrid:
- m_value.valueID = CSSValueInlineGrid;
+ m_valueID = CSSValueInlineGrid;
break;
case EDisplay::None:
- m_value.valueID = CSSValueNone;
+ m_valueID = CSSValueNone;
break;
}
}
-template<> inline EDisplay CSSPrimitiveValue::convertTo() const
+template<> inline EDisplay CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- if (m_value.valueID == CSSValueNone)
+ if (m_valueID == CSSValueNone)
return EDisplay::None;
- if (m_value.valueID == CSSValueWebkitFlex)
+ if (m_valueID == CSSValueWebkitFlex)
return EDisplay::Flex;
- if (m_value.valueID == CSSValueWebkitInlineFlex)
+ if (m_valueID == CSSValueWebkitInlineFlex)
return EDisplay::InlineFlex;
- EDisplay display = static_cast<EDisplay>(m_value.valueID - CSSValueInline);
+ EDisplay display = static_cast<EDisplay>(m_valueID - CSSValueInline);
// TODO(sashab): Check display is a valid EDisplay here.
return display;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EEmptyCells e)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(EEmptyCells e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
case EEmptyCells::Show:
- m_value.valueID = CSSValueShow;
+ m_valueID = CSSValueShow;
break;
case EEmptyCells::Hide:
- m_value.valueID = CSSValueHide;
+ m_valueID = CSSValueHide;
break;
}
}
-template<> inline EEmptyCells CSSPrimitiveValue::convertTo() const
+template<> inline EEmptyCells CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueShow:
return EEmptyCells::Show;
case CSSValueHide:
@@ -1289,30 +1244,28 @@ template<> inline EEmptyCells CSSPrimitiveValue::convertTo() const
return EEmptyCells::Show;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFlexDirection e)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(EFlexDirection e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
case FlowRow:
- m_value.valueID = CSSValueRow;
+ m_valueID = CSSValueRow;
break;
case FlowRowReverse:
- m_value.valueID = CSSValueRowReverse;
+ m_valueID = CSSValueRowReverse;
break;
case FlowColumn:
- m_value.valueID = CSSValueColumn;
+ m_valueID = CSSValueColumn;
break;
case FlowColumnReverse:
- m_value.valueID = CSSValueColumnReverse;
+ m_valueID = CSSValueColumnReverse;
break;
}
}
-template<> inline EFlexDirection CSSPrimitiveValue::convertTo() const
+template<> inline EFlexDirection CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueRow:
return FlowRow;
case CSSValueRowReverse:
@@ -1329,27 +1282,25 @@ template<> inline EFlexDirection CSSPrimitiveValue::convertTo() const
return FlowRow;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFlexWrap e)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(EFlexWrap e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
case FlexNoWrap:
- m_value.valueID = CSSValueNowrap;
+ m_valueID = CSSValueNowrap;
break;
case FlexWrap:
- m_value.valueID = CSSValueWrap;
+ m_valueID = CSSValueWrap;
break;
case FlexWrapReverse:
- m_value.valueID = CSSValueWrapReverse;
+ m_valueID = CSSValueWrapReverse;
break;
}
}
-template<> inline EFlexWrap CSSPrimitiveValue::convertTo() const
+template<> inline EFlexWrap CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueNowrap:
return FlexNoWrap;
case CSSValueWrap:
@@ -1364,27 +1315,25 @@ template<> inline EFlexWrap CSSPrimitiveValue::convertTo() const
return FlexNoWrap;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFloat e)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(EFloat e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
case EFloat::None:
- m_value.valueID = CSSValueNone;
+ m_valueID = CSSValueNone;
break;
case EFloat::Left:
- m_value.valueID = CSSValueLeft;
+ m_valueID = CSSValueLeft;
break;
case EFloat::Right:
- m_value.valueID = CSSValueRight;
+ m_valueID = CSSValueRight;
break;
}
}
-template<> inline EFloat CSSPrimitiveValue::convertTo() const
+template<> inline EFloat CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueLeft:
return EFloat::Left;
case CSSValueRight:
@@ -1399,27 +1348,25 @@ template<> inline EFloat CSSPrimitiveValue::convertTo() const
return EFloat::None;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(Hyphens e)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(Hyphens e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
case HyphensAuto:
- m_value.valueID = CSSValueAuto;
+ m_valueID = CSSValueAuto;
break;
case HyphensManual:
- m_value.valueID = CSSValueManual;
+ m_valueID = CSSValueManual;
break;
case HyphensNone:
- m_value.valueID = CSSValueNone;
+ m_valueID = CSSValueNone;
break;
}
}
-template<> inline Hyphens CSSPrimitiveValue::convertTo() const
+template<> inline Hyphens CSSIdentifierValue::convertTo() const
{
- DCHECK(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueAuto:
return HyphensAuto;
case CSSValueManual:
@@ -1434,33 +1381,31 @@ template<> inline Hyphens CSSPrimitiveValue::convertTo() const
return HyphensManual;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineBreak e)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(LineBreak e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
case LineBreakAuto:
- m_value.valueID = CSSValueAuto;
+ m_valueID = CSSValueAuto;
break;
case LineBreakLoose:
- m_value.valueID = CSSValueLoose;
+ m_valueID = CSSValueLoose;
break;
case LineBreakNormal:
- m_value.valueID = CSSValueNormal;
+ m_valueID = CSSValueNormal;
break;
case LineBreakStrict:
- m_value.valueID = CSSValueStrict;
+ m_valueID = CSSValueStrict;
break;
case LineBreakAfterWhiteSpace:
- m_value.valueID = CSSValueAfterWhiteSpace;
+ m_valueID = CSSValueAfterWhiteSpace;
break;
}
}
-template<> inline LineBreak CSSPrimitiveValue::convertTo() const
+template<> inline LineBreak CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueAuto:
return LineBreakAuto;
case CSSValueLoose:
@@ -1479,24 +1424,22 @@ template<> inline LineBreak CSSPrimitiveValue::convertTo() const
return LineBreakAuto;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EListStylePosition e)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(EListStylePosition e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
case ListStylePositionOutside:
- m_value.valueID = CSSValueOutside;
+ m_valueID = CSSValueOutside;
break;
case ListStylePositionInside:
- m_value.valueID = CSSValueInside;
+ m_valueID = CSSValueInside;
break;
}
}
-template<> inline EListStylePosition CSSPrimitiveValue::convertTo() const
+template<> inline EListStylePosition CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueOutside:
return ListStylePositionOutside;
case CSSValueInside:
@@ -1509,214 +1452,210 @@ template<> inline EListStylePosition CSSPrimitiveValue::convertTo() const
return ListStylePositionOutside;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EListStyleType e)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(EListStyleType e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
case ArabicIndic:
- m_value.valueID = CSSValueArabicIndic;
+ m_valueID = CSSValueArabicIndic;
break;
case Armenian:
- m_value.valueID = CSSValueArmenian;
+ m_valueID = CSSValueArmenian;
break;
case Bengali:
- m_value.valueID = CSSValueBengali;
+ m_valueID = CSSValueBengali;
break;
case Cambodian:
- m_value.valueID = CSSValueCambodian;
+ m_valueID = CSSValueCambodian;
break;
case Circle:
- m_value.valueID = CSSValueCircle;
+ m_valueID = CSSValueCircle;
break;
case CjkEarthlyBranch:
- m_value.valueID = CSSValueCjkEarthlyBranch;
+ m_valueID = CSSValueCjkEarthlyBranch;
break;
case CjkHeavenlyStem:
- m_value.valueID = CSSValueCjkHeavenlyStem;
+ m_valueID = CSSValueCjkHeavenlyStem;
break;
case CJKIdeographic:
- m_value.valueID = CSSValueCjkIdeographic;
+ m_valueID = CSSValueCjkIdeographic;
break;
case DecimalLeadingZero:
- m_value.valueID = CSSValueDecimalLeadingZero;
+ m_valueID = CSSValueDecimalLeadingZero;
break;
case DecimalListStyle:
- m_value.valueID = CSSValueDecimal;
+ m_valueID = CSSValueDecimal;
break;
case Devanagari:
- m_value.valueID = CSSValueDevanagari;
+ m_valueID = CSSValueDevanagari;
break;
case Disc:
- m_value.valueID = CSSValueDisc;
+ m_valueID = CSSValueDisc;
break;
case EthiopicHalehame:
- m_value.valueID = CSSValueEthiopicHalehame;
+ m_valueID = CSSValueEthiopicHalehame;
break;
case EthiopicHalehameAm:
- m_value.valueID = CSSValueEthiopicHalehameAm;
+ m_valueID = CSSValueEthiopicHalehameAm;
break;
case EthiopicHalehameTiEt:
- m_value.valueID = CSSValueEthiopicHalehameTiEt;
+ m_valueID = CSSValueEthiopicHalehameTiEt;
break;
case EthiopicHalehameTiEr:
- m_value.valueID = CSSValueEthiopicHalehameTiEr;
+ m_valueID = CSSValueEthiopicHalehameTiEr;
break;
case Georgian:
- m_value.valueID = CSSValueGeorgian;
+ m_valueID = CSSValueGeorgian;
break;
case Gujarati:
- m_value.valueID = CSSValueGujarati;
+ m_valueID = CSSValueGujarati;
break;
case Gurmukhi:
- m_value.valueID = CSSValueGurmukhi;
+ m_valueID = CSSValueGurmukhi;
break;
case Hangul:
- m_value.valueID = CSSValueHangul;
+ m_valueID = CSSValueHangul;
break;
case HangulConsonant:
- m_value.valueID = CSSValueHangulConsonant;
+ m_valueID = CSSValueHangulConsonant;
break;
case KoreanHangulFormal:
- m_value.valueID = CSSValueKoreanHangulFormal;
+ m_valueID = CSSValueKoreanHangulFormal;
break;
case KoreanHanjaFormal:
- m_value.valueID = CSSValueKoreanHanjaFormal;
+ m_valueID = CSSValueKoreanHanjaFormal;
break;
case KoreanHanjaInformal:
- m_value.valueID = CSSValueKoreanHanjaInformal;
+ m_valueID = CSSValueKoreanHanjaInformal;
break;
case Hebrew:
- m_value.valueID = CSSValueHebrew;
+ m_valueID = CSSValueHebrew;
break;
case Hiragana:
- m_value.valueID = CSSValueHiragana;
+ m_valueID = CSSValueHiragana;
break;
case HiraganaIroha:
- m_value.valueID = CSSValueHiraganaIroha;
+ m_valueID = CSSValueHiraganaIroha;
break;
case Kannada:
- m_value.valueID = CSSValueKannada;
+ m_valueID = CSSValueKannada;
break;
case Katakana:
- m_value.valueID = CSSValueKatakana;
+ m_valueID = CSSValueKatakana;
break;
case KatakanaIroha:
- m_value.valueID = CSSValueKatakanaIroha;
+ m_valueID = CSSValueKatakanaIroha;
break;
case Khmer:
- m_value.valueID = CSSValueKhmer;
+ m_valueID = CSSValueKhmer;
break;
case Lao:
- m_value.valueID = CSSValueLao;
+ m_valueID = CSSValueLao;
break;
case LowerAlpha:
- m_value.valueID = CSSValueLowerAlpha;
+ m_valueID = CSSValueLowerAlpha;
break;
case LowerArmenian:
- m_value.valueID = CSSValueLowerArmenian;
+ m_valueID = CSSValueLowerArmenian;
break;
case LowerGreek:
- m_value.valueID = CSSValueLowerGreek;
+ m_valueID = CSSValueLowerGreek;
break;
case LowerLatin:
- m_value.valueID = CSSValueLowerLatin;
+ m_valueID = CSSValueLowerLatin;
break;
case LowerRoman:
- m_value.valueID = CSSValueLowerRoman;
+ m_valueID = CSSValueLowerRoman;
break;
case Malayalam:
- m_value.valueID = CSSValueMalayalam;
+ m_valueID = CSSValueMalayalam;
break;
case Mongolian:
- m_value.valueID = CSSValueMongolian;
+ m_valueID = CSSValueMongolian;
break;
case Myanmar:
- m_value.valueID = CSSValueMyanmar;
+ m_valueID = CSSValueMyanmar;
break;
case NoneListStyle:
- m_value.valueID = CSSValueNone;
+ m_valueID = CSSValueNone;
break;
case Oriya:
- m_value.valueID = CSSValueOriya;
+ m_valueID = CSSValueOriya;
break;
case Persian:
- m_value.valueID = CSSValuePersian;
+ m_valueID = CSSValuePersian;
break;
case SimpChineseFormal:
- m_value.valueID = CSSValueSimpChineseFormal;
+ m_valueID = CSSValueSimpChineseFormal;
break;
case SimpChineseInformal:
- m_value.valueID = CSSValueSimpChineseInformal;
+ m_valueID = CSSValueSimpChineseInformal;
break;
case Square:
- m_value.valueID = CSSValueSquare;
+ m_valueID = CSSValueSquare;
break;
case Telugu:
- m_value.valueID = CSSValueTelugu;
+ m_valueID = CSSValueTelugu;
break;
case Thai:
- m_value.valueID = CSSValueThai;
+ m_valueID = CSSValueThai;
break;
case Tibetan:
- m_value.valueID = CSSValueTibetan;
+ m_valueID = CSSValueTibetan;
break;
case TradChineseFormal:
- m_value.valueID = CSSValueTradChineseFormal;
+ m_valueID = CSSValueTradChineseFormal;
break;
case TradChineseInformal:
- m_value.valueID = CSSValueTradChineseInformal;
+ m_valueID = CSSValueTradChineseInformal;
break;
case UpperAlpha:
- m_value.valueID = CSSValueUpperAlpha;
+ m_valueID = CSSValueUpperAlpha;
break;
case UpperArmenian:
- m_value.valueID = CSSValueUpperArmenian;
+ m_valueID = CSSValueUpperArmenian;
break;
case UpperLatin:
- m_value.valueID = CSSValueUpperLatin;
+ m_valueID = CSSValueUpperLatin;
break;
case UpperRoman:
- m_value.valueID = CSSValueUpperRoman;
+ m_valueID = CSSValueUpperRoman;
break;
case Urdu:
- m_value.valueID = CSSValueUrdu;
+ m_valueID = CSSValueUrdu;
break;
}
}
-template<> inline EListStyleType CSSPrimitiveValue::convertTo() const
+template<> inline EListStyleType CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueNone:
return NoneListStyle;
default:
- return static_cast<EListStyleType>(m_value.valueID - CSSValueDisc);
+ return static_cast<EListStyleType>(m_valueID - CSSValueDisc);
}
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EMarginCollapse e)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(EMarginCollapse e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
case MarginCollapseCollapse:
- m_value.valueID = CSSValueCollapse;
+ m_valueID = CSSValueCollapse;
break;
case MarginCollapseSeparate:
- m_value.valueID = CSSValueSeparate;
+ m_valueID = CSSValueSeparate;
break;
case MarginCollapseDiscard:
- m_value.valueID = CSSValueDiscard;
+ m_valueID = CSSValueDiscard;
break;
}
}
-template<> inline EMarginCollapse CSSPrimitiveValue::convertTo() const
+template<> inline EMarginCollapse CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueCollapse:
return MarginCollapseCollapse;
case CSSValueSeparate:
@@ -1731,39 +1670,37 @@ template<> inline EMarginCollapse CSSPrimitiveValue::convertTo() const
return MarginCollapseCollapse;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EOverflow e)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(EOverflow e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
case OverflowVisible:
- m_value.valueID = CSSValueVisible;
+ m_valueID = CSSValueVisible;
break;
case OverflowHidden:
- m_value.valueID = CSSValueHidden;
+ m_valueID = CSSValueHidden;
break;
case OverflowScroll:
- m_value.valueID = CSSValueScroll;
+ m_valueID = CSSValueScroll;
break;
case OverflowAuto:
- m_value.valueID = CSSValueAuto;
+ m_valueID = CSSValueAuto;
break;
case OverflowOverlay:
- m_value.valueID = CSSValueOverlay;
+ m_valueID = CSSValueOverlay;
break;
case OverflowPagedX:
- m_value.valueID = CSSValueWebkitPagedX;
+ m_valueID = CSSValueWebkitPagedX;
break;
case OverflowPagedY:
- m_value.valueID = CSSValueWebkitPagedY;
+ m_valueID = CSSValueWebkitPagedY;
break;
}
}
-template<> inline EOverflow CSSPrimitiveValue::convertTo() const
+template<> inline EOverflow CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueVisible:
return OverflowVisible;
case CSSValueHidden:
@@ -1786,53 +1723,51 @@ template<> inline EOverflow CSSPrimitiveValue::convertTo() const
return OverflowVisible;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBreak e)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(EBreak e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
default:
ASSERT_NOT_REACHED();
case BreakAuto:
- m_value.valueID = CSSValueAuto;
+ m_valueID = CSSValueAuto;
break;
case BreakAlways:
- m_value.valueID = CSSValueAlways;
+ m_valueID = CSSValueAlways;
break;
case BreakAvoid:
- m_value.valueID = CSSValueAvoid;
+ m_valueID = CSSValueAvoid;
break;
case BreakAvoidPage:
- m_value.valueID = CSSValueAvoidPage;
+ m_valueID = CSSValueAvoidPage;
break;
case BreakPage:
- m_value.valueID = CSSValuePage;
+ m_valueID = CSSValuePage;
break;
case BreakLeft:
- m_value.valueID = CSSValueLeft;
+ m_valueID = CSSValueLeft;
break;
case BreakRight:
- m_value.valueID = CSSValueRight;
+ m_valueID = CSSValueRight;
break;
case BreakRecto:
- m_value.valueID = CSSValueRecto;
+ m_valueID = CSSValueRecto;
break;
case BreakVerso:
- m_value.valueID = CSSValueVerso;
+ m_valueID = CSSValueVerso;
break;
case BreakAvoidColumn:
- m_value.valueID = CSSValueAvoidColumn;
+ m_valueID = CSSValueAvoidColumn;
break;
case BreakColumn:
- m_value.valueID = CSSValueColumn;
+ m_valueID = CSSValueColumn;
break;
}
}
-template<> inline EBreak CSSPrimitiveValue::convertTo() const
+template<> inline EBreak CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
default:
ASSERT_NOT_REACHED();
case CSSValueAuto:
@@ -1860,33 +1795,31 @@ template<> inline EBreak CSSPrimitiveValue::convertTo() const
}
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EPosition e)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(EPosition e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
case StaticPosition:
- m_value.valueID = CSSValueStatic;
+ m_valueID = CSSValueStatic;
break;
case RelativePosition:
- m_value.valueID = CSSValueRelative;
+ m_valueID = CSSValueRelative;
break;
case AbsolutePosition:
- m_value.valueID = CSSValueAbsolute;
+ m_valueID = CSSValueAbsolute;
break;
case FixedPosition:
- m_value.valueID = CSSValueFixed;
+ m_valueID = CSSValueFixed;
break;
case StickyPosition:
- m_value.valueID = CSSValueSticky;
+ m_valueID = CSSValueSticky;
break;
}
}
-template<> inline EPosition CSSPrimitiveValue::convertTo() const
+template<> inline EPosition CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueStatic:
return StaticPosition;
case CSSValueRelative:
@@ -1905,30 +1838,28 @@ template<> inline EPosition CSSPrimitiveValue::convertTo() const
return StaticPosition;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EResize e)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(EResize e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
case RESIZE_BOTH:
- m_value.valueID = CSSValueBoth;
+ m_valueID = CSSValueBoth;
break;
case RESIZE_HORIZONTAL:
- m_value.valueID = CSSValueHorizontal;
+ m_valueID = CSSValueHorizontal;
break;
case RESIZE_VERTICAL:
- m_value.valueID = CSSValueVertical;
+ m_valueID = CSSValueVertical;
break;
case RESIZE_NONE:
- m_value.valueID = CSSValueNone;
+ m_valueID = CSSValueNone;
break;
}
}
-template<> inline EResize CSSPrimitiveValue::convertTo() const
+template<> inline EResize CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueBoth:
return RESIZE_BOTH;
case CSSValueHorizontal:
@@ -1948,24 +1879,22 @@ template<> inline EResize CSSPrimitiveValue::convertTo() const
return RESIZE_NONE;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETableLayout e)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(ETableLayout e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
case TableLayoutAuto:
- m_value.valueID = CSSValueAuto;
+ m_valueID = CSSValueAuto;
break;
case TableLayoutFixed:
- m_value.valueID = CSSValueFixed;
+ m_valueID = CSSValueFixed;
break;
}
}
-template<> inline ETableLayout CSSPrimitiveValue::convertTo() const
+template<> inline ETableLayout CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueFixed:
return TableLayoutFixed;
case CSSValueAuto:
@@ -1978,45 +1907,43 @@ template<> inline ETableLayout CSSPrimitiveValue::convertTo() const
return TableLayoutAuto;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETextAlign e)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(ETextAlign e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
case TASTART:
- m_value.valueID = CSSValueStart;
+ m_valueID = CSSValueStart;
break;
case TAEND:
- m_value.valueID = CSSValueEnd;
+ m_valueID = CSSValueEnd;
break;
case LEFT:
- m_value.valueID = CSSValueLeft;
+ m_valueID = CSSValueLeft;
break;
case RIGHT:
- m_value.valueID = CSSValueRight;
+ m_valueID = CSSValueRight;
break;
case CENTER:
- m_value.valueID = CSSValueCenter;
+ m_valueID = CSSValueCenter;
break;
case JUSTIFY:
- m_value.valueID = CSSValueJustify;
+ m_valueID = CSSValueJustify;
break;
case WEBKIT_LEFT:
- m_value.valueID = CSSValueWebkitLeft;
+ m_valueID = CSSValueWebkitLeft;
break;
case WEBKIT_RIGHT:
- m_value.valueID = CSSValueWebkitRight;
+ m_valueID = CSSValueWebkitRight;
break;
case WEBKIT_CENTER:
- m_value.valueID = CSSValueWebkitCenter;
+ m_valueID = CSSValueWebkitCenter;
break;
}
}
-template<> inline ETextAlign CSSPrimitiveValue::convertTo() const
+template<> inline ETextAlign CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueWebkitAuto: // Legacy -webkit-auto. Eqiuvalent to start.
case CSSValueStart:
return TASTART;
@@ -2025,43 +1952,41 @@ template<> inline ETextAlign CSSPrimitiveValue::convertTo() const
case CSSValueInternalCenter:
return CENTER;
default:
- return static_cast<ETextAlign>(m_value.valueID - CSSValueLeft);
+ return static_cast<ETextAlign>(m_valueID - CSSValueLeft);
}
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextAlignLast e)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(TextAlignLast e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
case TextAlignLastStart:
- m_value.valueID = CSSValueStart;
+ m_valueID = CSSValueStart;
break;
case TextAlignLastEnd:
- m_value.valueID = CSSValueEnd;
+ m_valueID = CSSValueEnd;
break;
case TextAlignLastLeft:
- m_value.valueID = CSSValueLeft;
+ m_valueID = CSSValueLeft;
break;
case TextAlignLastRight:
- m_value.valueID = CSSValueRight;
+ m_valueID = CSSValueRight;
break;
case TextAlignLastCenter:
- m_value.valueID = CSSValueCenter;
+ m_valueID = CSSValueCenter;
break;
case TextAlignLastJustify:
- m_value.valueID = CSSValueJustify;
+ m_valueID = CSSValueJustify;
break;
case TextAlignLastAuto:
- m_value.valueID = CSSValueAuto;
+ m_valueID = CSSValueAuto;
break;
}
}
-template<> inline TextAlignLast CSSPrimitiveValue::convertTo() const
+template<> inline TextAlignLast CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueAuto:
return TextAlignLastAuto;
case CSSValueStart:
@@ -2084,29 +2009,28 @@ template<> inline TextAlignLast CSSPrimitiveValue::convertTo() const
return TextAlignLastAuto;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextJustify e)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(TextJustify e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
case TextJustifyAuto:
- m_value.valueID = CSSValueAuto;
+ m_valueID = CSSValueAuto;
break;
case TextJustifyNone:
- m_value.valueID = CSSValueNone;
+ m_valueID = CSSValueNone;
break;
case TextJustifyInterWord:
- m_value.valueID = CSSValueInterWord;
+ m_valueID = CSSValueInterWord;
break;
case TextJustifyDistribute:
- m_value.valueID = CSSValueDistribute;
+ m_valueID = CSSValueDistribute;
break;
}
}
-template<> inline TextJustify CSSPrimitiveValue::convertTo() const
+template<> inline TextJustify CSSIdentifierValue::convertTo() const
{
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueAuto:
return TextJustifyAuto;
case CSSValueNone:
@@ -2123,10 +2047,9 @@ template<> inline TextJustify CSSPrimitiveValue::convertTo() const
return TextJustifyAuto;
}
-template<> inline TextDecoration CSSPrimitiveValue::convertTo() const
+template<> inline TextDecoration CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueNone:
return TextDecorationNone;
case CSSValueUnderline:
@@ -2145,10 +2068,9 @@ template<> inline TextDecoration CSSPrimitiveValue::convertTo() const
return TextDecorationNone;
}
-template<> inline TextDecorationStyle CSSPrimitiveValue::convertTo() const
+template<> inline TextDecorationStyle CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueSolid:
return TextDecorationStyleSolid;
case CSSValueDouble:
@@ -2167,26 +2089,24 @@ template<> inline TextDecorationStyle CSSPrimitiveValue::convertTo() const
return TextDecorationStyleSolid;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextUnderlinePosition e)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(TextUnderlinePosition e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
case TextUnderlinePositionAuto:
- m_value.valueID = CSSValueAuto;
+ m_valueID = CSSValueAuto;
break;
case TextUnderlinePositionUnder:
- m_value.valueID = CSSValueUnder;
+ m_valueID = CSSValueUnder;
break;
}
// FIXME: Implement support for 'under left' and 'under right' values.
}
-template<> inline TextUnderlinePosition CSSPrimitiveValue::convertTo() const
+template<> inline TextUnderlinePosition CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueAuto:
return TextUnderlinePositionAuto;
case CSSValueUnder:
@@ -2201,30 +2121,28 @@ template<> inline TextUnderlinePosition CSSPrimitiveValue::convertTo() const
return TextUnderlinePositionAuto;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETextSecurity e)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(ETextSecurity e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
case TSNONE:
- m_value.valueID = CSSValueNone;
+ m_valueID = CSSValueNone;
break;
case TSDISC:
- m_value.valueID = CSSValueDisc;
+ m_valueID = CSSValueDisc;
break;
case TSCIRCLE:
- m_value.valueID = CSSValueCircle;
+ m_valueID = CSSValueCircle;
break;
case TSSQUARE:
- m_value.valueID = CSSValueSquare;
+ m_valueID = CSSValueSquare;
break;
}
}
-template<> inline ETextSecurity CSSPrimitiveValue::convertTo() const
+template<> inline ETextSecurity CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueNone:
return TSNONE;
case CSSValueDisc:
@@ -2241,30 +2159,28 @@ template<> inline ETextSecurity CSSPrimitiveValue::convertTo() const
return TSNONE;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETextTransform e)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(ETextTransform e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
case CAPITALIZE:
- m_value.valueID = CSSValueCapitalize;
+ m_valueID = CSSValueCapitalize;
break;
case UPPERCASE:
- m_value.valueID = CSSValueUppercase;
+ m_valueID = CSSValueUppercase;
break;
case LOWERCASE:
- m_value.valueID = CSSValueLowercase;
+ m_valueID = CSSValueLowercase;
break;
case TTNONE:
- m_value.valueID = CSSValueNone;
+ m_valueID = CSSValueNone;
break;
}
}
-template<> inline ETextTransform CSSPrimitiveValue::convertTo() const
+template<> inline ETextTransform CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueCapitalize:
return CAPITALIZE;
case CSSValueUppercase:
@@ -2281,36 +2197,34 @@ template<> inline ETextTransform CSSPrimitiveValue::convertTo() const
return TTNONE;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUnicodeBidi e)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(EUnicodeBidi e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
case UBNormal:
- m_value.valueID = CSSValueNormal;
+ m_valueID = CSSValueNormal;
break;
case Embed:
- m_value.valueID = CSSValueEmbed;
+ m_valueID = CSSValueEmbed;
break;
case Override:
- m_value.valueID = CSSValueBidiOverride;
+ m_valueID = CSSValueBidiOverride;
break;
case Isolate:
- m_value.valueID = CSSValueIsolate;
+ m_valueID = CSSValueIsolate;
break;
case IsolateOverride:
- m_value.valueID = CSSValueIsolateOverride;
+ m_valueID = CSSValueIsolateOverride;
break;
case Plaintext:
- m_value.valueID = CSSValuePlaintext;
+ m_valueID = CSSValuePlaintext;
break;
}
}
-template<> inline EUnicodeBidi CSSPrimitiveValue::convertTo() const
+template<> inline EUnicodeBidi CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueNormal:
return UBNormal;
case CSSValueEmbed:
@@ -2334,29 +2248,27 @@ template<> inline EUnicodeBidi CSSPrimitiveValue::convertTo() const
return UBNormal;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUserDrag e)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(EUserDrag e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
case DRAG_AUTO:
- m_value.valueID = CSSValueAuto;
+ m_valueID = CSSValueAuto;
break;
case DRAG_NONE:
- m_value.valueID = CSSValueNone;
+ m_valueID = CSSValueNone;
break;
case DRAG_ELEMENT:
- m_value.valueID = CSSValueElement;
+ m_valueID = CSSValueElement;
break;
default:
break;
}
}
-template<> inline EUserDrag CSSPrimitiveValue::convertTo() const
+template<> inline EUserDrag CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueAuto:
return DRAG_AUTO;
case CSSValueNone:
@@ -2371,27 +2283,25 @@ template<> inline EUserDrag CSSPrimitiveValue::convertTo() const
return DRAG_AUTO;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUserModify e)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(EUserModify e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
case READ_ONLY:
- m_value.valueID = CSSValueReadOnly;
+ m_valueID = CSSValueReadOnly;
break;
case READ_WRITE:
- m_value.valueID = CSSValueReadWrite;
+ m_valueID = CSSValueReadWrite;
break;
case READ_WRITE_PLAINTEXT_ONLY:
- m_value.valueID = CSSValueReadWritePlaintextOnly;
+ m_valueID = CSSValueReadWritePlaintextOnly;
break;
}
}
-template<> inline EUserModify CSSPrimitiveValue::convertTo() const
+template<> inline EUserModify CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueReadOnly:
return READ_ONLY;
case CSSValueReadWrite:
@@ -2406,27 +2316,25 @@ template<> inline EUserModify CSSPrimitiveValue::convertTo() const
return READ_ONLY;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUserSelect e)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(EUserSelect e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
case SELECT_NONE:
- m_value.valueID = CSSValueNone;
+ m_valueID = CSSValueNone;
break;
case SELECT_TEXT:
- m_value.valueID = CSSValueText;
+ m_valueID = CSSValueText;
break;
case SELECT_ALL:
- m_value.valueID = CSSValueAll;
+ m_valueID = CSSValueAll;
break;
}
}
-template<> inline EUserSelect CSSPrimitiveValue::convertTo() const
+template<> inline EUserSelect CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueAuto:
return SELECT_TEXT;
case CSSValueNone:
@@ -2443,47 +2351,45 @@ template<> inline EUserSelect CSSPrimitiveValue::convertTo() const
return SELECT_TEXT;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EVerticalAlign a)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(EVerticalAlign a)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (a) {
case VerticalAlignTop:
- m_value.valueID = CSSValueTop;
+ m_valueID = CSSValueTop;
break;
case VerticalAlignBottom:
- m_value.valueID = CSSValueBottom;
+ m_valueID = CSSValueBottom;
break;
case VerticalAlignMiddle:
- m_value.valueID = CSSValueMiddle;
+ m_valueID = CSSValueMiddle;
break;
case VerticalAlignBaseline:
- m_value.valueID = CSSValueBaseline;
+ m_valueID = CSSValueBaseline;
break;
case VerticalAlignTextBottom:
- m_value.valueID = CSSValueTextBottom;
+ m_valueID = CSSValueTextBottom;
break;
case VerticalAlignTextTop:
- m_value.valueID = CSSValueTextTop;
+ m_valueID = CSSValueTextTop;
break;
case VerticalAlignSub:
- m_value.valueID = CSSValueSub;
+ m_valueID = CSSValueSub;
break;
case VerticalAlignSuper:
- m_value.valueID = CSSValueSuper;
+ m_valueID = CSSValueSuper;
break;
case VerticalAlignBaselineMiddle:
- m_value.valueID = CSSValueWebkitBaselineMiddle;
+ m_valueID = CSSValueWebkitBaselineMiddle;
break;
case VerticalAlignLength:
- m_value.valueID = CSSValueInvalid;
+ m_valueID = CSSValueInvalid;
}
}
-template<> inline EVerticalAlign CSSPrimitiveValue::convertTo() const
+template<> inline EVerticalAlign CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueTop:
return VerticalAlignTop;
case CSSValueBottom:
@@ -2510,27 +2416,25 @@ template<> inline EVerticalAlign CSSPrimitiveValue::convertTo() const
return VerticalAlignTop;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EVisibility e)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(EVisibility e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
case EVisibility::Visible:
- m_value.valueID = CSSValueVisible;
+ m_valueID = CSSValueVisible;
break;
case EVisibility::Hidden:
- m_value.valueID = CSSValueHidden;
+ m_valueID = CSSValueHidden;
break;
case EVisibility::Collapse:
- m_value.valueID = CSSValueCollapse;
+ m_valueID = CSSValueCollapse;
break;
}
}
-template<> inline EVisibility CSSPrimitiveValue::convertTo() const
+template<> inline EVisibility CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueHidden:
return EVisibility::Hidden;
case CSSValueVisible:
@@ -2545,36 +2449,34 @@ template<> inline EVisibility CSSPrimitiveValue::convertTo() const
return EVisibility::Visible;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EWhiteSpace e)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(EWhiteSpace e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
case NORMAL:
- m_value.valueID = CSSValueNormal;
+ m_valueID = CSSValueNormal;
break;
case PRE:
- m_value.valueID = CSSValuePre;
+ m_valueID = CSSValuePre;
break;
case PRE_WRAP:
- m_value.valueID = CSSValuePreWrap;
+ m_valueID = CSSValuePreWrap;
break;
case PRE_LINE:
- m_value.valueID = CSSValuePreLine;
+ m_valueID = CSSValuePreLine;
break;
case NOWRAP:
- m_value.valueID = CSSValueNowrap;
+ m_valueID = CSSValueNowrap;
break;
case KHTML_NOWRAP:
- m_value.valueID = CSSValueWebkitNowrap;
+ m_valueID = CSSValueWebkitNowrap;
break;
}
}
-template<> inline EWhiteSpace CSSPrimitiveValue::convertTo() const
+template<> inline EWhiteSpace CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueWebkitNowrap:
return KHTML_NOWRAP;
case CSSValueNowrap:
@@ -2595,30 +2497,28 @@ template<> inline EWhiteSpace CSSPrimitiveValue::convertTo() const
return NORMAL;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EWordBreak e)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(EWordBreak e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
case NormalWordBreak:
- m_value.valueID = CSSValueNormal;
+ m_valueID = CSSValueNormal;
break;
case BreakAllWordBreak:
- m_value.valueID = CSSValueBreakAll;
+ m_valueID = CSSValueBreakAll;
break;
case BreakWordBreak:
- m_value.valueID = CSSValueBreakWord;
+ m_valueID = CSSValueBreakWord;
break;
case KeepAllWordBreak:
- m_value.valueID = CSSValueKeepAll;
+ m_valueID = CSSValueKeepAll;
break;
}
}
-template<> inline EWordBreak CSSPrimitiveValue::convertTo() const
+template<> inline EWordBreak CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueBreakAll:
return BreakAllWordBreak;
case CSSValueBreakWord:
@@ -2635,27 +2535,25 @@ template<> inline EWordBreak CSSPrimitiveValue::convertTo() const
return NormalWordBreak;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EOverflowAnchor e)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(EOverflowAnchor e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
case AnchorVisible:
- m_value.valueID = CSSValueVisible;
+ m_valueID = CSSValueVisible;
break;
case AnchorNone:
- m_value.valueID = CSSValueNone;
+ m_valueID = CSSValueNone;
break;
case AnchorAuto:
- m_value.valueID = CSSValueAuto;
+ m_valueID = CSSValueAuto;
break;
}
}
-template<> inline EOverflowAnchor CSSPrimitiveValue::convertTo() const
+template<> inline EOverflowAnchor CSSIdentifierValue::convertTo() const
{
- DCHECK(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueVisible:
return AnchorVisible;
case CSSValueNone:
@@ -2670,24 +2568,22 @@ template<> inline EOverflowAnchor CSSPrimitiveValue::convertTo() const
return AnchorNone;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EOverflowWrap e)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(EOverflowWrap e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
case NormalOverflowWrap:
- m_value.valueID = CSSValueNormal;
+ m_valueID = CSSValueNormal;
break;
case BreakOverflowWrap:
- m_value.valueID = CSSValueBreakWord;
+ m_valueID = CSSValueBreakWord;
break;
}
}
-template<> inline EOverflowWrap CSSPrimitiveValue::convertTo() const
+template<> inline EOverflowWrap CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueBreakWord:
return BreakOverflowWrap;
case CSSValueNormal:
@@ -2700,24 +2596,22 @@ template<> inline EOverflowWrap CSSPrimitiveValue::convertTo() const
return NormalOverflowWrap;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextDirection e)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(TextDirection e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
case LTR:
- m_value.valueID = CSSValueLtr;
+ m_valueID = CSSValueLtr;
break;
case RTL:
- m_value.valueID = CSSValueRtl;
+ m_valueID = CSSValueRtl;
break;
}
}
-template<> inline TextDirection CSSPrimitiveValue::convertTo() const
+template<> inline TextDirection CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueLtr:
return LTR;
case CSSValueRtl:
@@ -2730,27 +2624,25 @@ template<> inline TextDirection CSSPrimitiveValue::convertTo() const
return LTR;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(WritingMode e)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(WritingMode e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
case TopToBottomWritingMode:
- m_value.valueID = CSSValueHorizontalTb;
+ m_valueID = CSSValueHorizontalTb;
break;
case RightToLeftWritingMode:
- m_value.valueID = CSSValueVerticalRl;
+ m_valueID = CSSValueVerticalRl;
break;
case LeftToRightWritingMode:
- m_value.valueID = CSSValueVerticalLr;
+ m_valueID = CSSValueVerticalLr;
break;
}
}
-template<> inline WritingMode CSSPrimitiveValue::convertTo() const
+template<> inline WritingMode CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueHorizontalTb:
case CSSValueLr:
case CSSValueLrTb:
@@ -2771,24 +2663,22 @@ template<> inline WritingMode CSSPrimitiveValue::convertTo() const
return TopToBottomWritingMode;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextCombine e)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(TextCombine e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
case TextCombineNone:
- m_value.valueID = CSSValueNone;
+ m_valueID = CSSValueNone;
break;
case TextCombineAll:
- m_value.valueID = CSSValueAll;
+ m_valueID = CSSValueAll;
break;
}
}
-template<> inline TextCombine CSSPrimitiveValue::convertTo() const
+template<> inline TextCombine CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueNone:
return TextCombineNone;
case CSSValueAll:
@@ -2802,24 +2692,22 @@ template<> inline TextCombine CSSPrimitiveValue::convertTo() const
return TextCombineNone;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(RubyPosition position)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(RubyPosition position)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (position) {
case RubyPositionBefore:
- m_value.valueID = CSSValueBefore;
+ m_valueID = CSSValueBefore;
break;
case RubyPositionAfter:
- m_value.valueID = CSSValueAfter;
+ m_valueID = CSSValueAfter;
break;
}
}
-template<> inline RubyPosition CSSPrimitiveValue::convertTo() const
+template<> inline RubyPosition CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueBefore:
return RubyPositionBefore;
case CSSValueAfter:
@@ -2832,24 +2720,22 @@ template<> inline RubyPosition CSSPrimitiveValue::convertTo() const
return RubyPositionBefore;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextEmphasisPosition position)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(TextEmphasisPosition position)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (position) {
case TextEmphasisPositionOver:
- m_value.valueID = CSSValueOver;
+ m_valueID = CSSValueOver;
break;
case TextEmphasisPositionUnder:
- m_value.valueID = CSSValueUnder;
+ m_valueID = CSSValueUnder;
break;
}
}
-template<> inline TextEmphasisPosition CSSPrimitiveValue::convertTo() const
+template<> inline TextEmphasisPosition CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueOver:
return TextEmphasisPositionOver;
case CSSValueUnder:
@@ -2862,24 +2748,22 @@ template<> inline TextEmphasisPosition CSSPrimitiveValue::convertTo() const
return TextEmphasisPositionOver;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextOverflow overflow)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(TextOverflow overflow)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (overflow) {
case TextOverflowClip:
- m_value.valueID = CSSValueClip;
+ m_valueID = CSSValueClip;
break;
case TextOverflowEllipsis:
- m_value.valueID = CSSValueEllipsis;
+ m_valueID = CSSValueEllipsis;
break;
}
}
-template<> inline TextOverflow CSSPrimitiveValue::convertTo() const
+template<> inline TextOverflow CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueClip:
return TextOverflowClip;
case CSSValueEllipsis:
@@ -2892,24 +2776,22 @@ template<> inline TextOverflow CSSPrimitiveValue::convertTo() const
return TextOverflowClip;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextEmphasisFill fill)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(TextEmphasisFill fill)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (fill) {
case TextEmphasisFillFilled:
- m_value.valueID = CSSValueFilled;
+ m_valueID = CSSValueFilled;
break;
case TextEmphasisFillOpen:
- m_value.valueID = CSSValueOpen;
+ m_valueID = CSSValueOpen;
break;
}
}
-template<> inline TextEmphasisFill CSSPrimitiveValue::convertTo() const
+template<> inline TextEmphasisFill CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueFilled:
return TextEmphasisFillFilled;
case CSSValueOpen:
@@ -2922,39 +2804,37 @@ template<> inline TextEmphasisFill CSSPrimitiveValue::convertTo() const
return TextEmphasisFillFilled;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextEmphasisMark mark)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(TextEmphasisMark mark)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (mark) {
case TextEmphasisMarkDot:
- m_value.valueID = CSSValueDot;
+ m_valueID = CSSValueDot;
break;
case TextEmphasisMarkCircle:
- m_value.valueID = CSSValueCircle;
+ m_valueID = CSSValueCircle;
break;
case TextEmphasisMarkDoubleCircle:
- m_value.valueID = CSSValueDoubleCircle;
+ m_valueID = CSSValueDoubleCircle;
break;
case TextEmphasisMarkTriangle:
- m_value.valueID = CSSValueTriangle;
+ m_valueID = CSSValueTriangle;
break;
case TextEmphasisMarkSesame:
- m_value.valueID = CSSValueSesame;
+ m_valueID = CSSValueSesame;
break;
case TextEmphasisMarkNone:
case TextEmphasisMarkAuto:
case TextEmphasisMarkCustom:
ASSERT_NOT_REACHED();
- m_value.valueID = CSSValueNone;
+ m_valueID = CSSValueNone;
break;
}
}
-template<> inline TextEmphasisMark CSSPrimitiveValue::convertTo() const
+template<> inline TextEmphasisMark CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueNone:
return TextEmphasisMarkNone;
case CSSValueDot:
@@ -2975,27 +2855,25 @@ template<> inline TextEmphasisMark CSSPrimitiveValue::convertTo() const
return TextEmphasisMarkNone;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextOrientation e)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(TextOrientation e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
case TextOrientationSideways:
- m_value.valueID = CSSValueSideways;
+ m_valueID = CSSValueSideways;
break;
case TextOrientationMixed:
- m_value.valueID = CSSValueMixed;
+ m_valueID = CSSValueMixed;
break;
case TextOrientationUpright:
- m_value.valueID = CSSValueUpright;
+ m_valueID = CSSValueUpright;
break;
}
}
-template<> inline TextOrientation CSSPrimitiveValue::convertTo() const
+template<> inline TextOrientation CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueSideways:
case CSSValueSidewaysRight:
return TextOrientationSideways;
@@ -3012,51 +2890,49 @@ template<> inline TextOrientation CSSPrimitiveValue::convertTo() const
return TextOrientationMixed;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EPointerEvents e)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(EPointerEvents e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
case PE_NONE:
- m_value.valueID = CSSValueNone;
+ m_valueID = CSSValueNone;
break;
case PE_STROKE:
- m_value.valueID = CSSValueStroke;
+ m_valueID = CSSValueStroke;
break;
case PE_FILL:
- m_value.valueID = CSSValueFill;
+ m_valueID = CSSValueFill;
break;
case PE_PAINTED:
- m_value.valueID = CSSValuePainted;
+ m_valueID = CSSValuePainted;
break;
case PE_VISIBLE:
- m_value.valueID = CSSValueVisible;
+ m_valueID = CSSValueVisible;
break;
case PE_VISIBLE_STROKE:
- m_value.valueID = CSSValueVisibleStroke;
+ m_valueID = CSSValueVisibleStroke;
break;
case PE_VISIBLE_FILL:
- m_value.valueID = CSSValueVisibleFill;
+ m_valueID = CSSValueVisibleFill;
break;
case PE_VISIBLE_PAINTED:
- m_value.valueID = CSSValueVisiblePainted;
+ m_valueID = CSSValueVisiblePainted;
break;
case PE_AUTO:
- m_value.valueID = CSSValueAuto;
+ m_valueID = CSSValueAuto;
break;
case PE_ALL:
- m_value.valueID = CSSValueAll;
+ m_valueID = CSSValueAll;
break;
case PE_BOUNDINGBOX:
- m_value.valueID = CSSValueBoundingBox;
+ m_valueID = CSSValueBoundingBox;
break;
}
}
-template<> inline EPointerEvents CSSPrimitiveValue::convertTo() const
+template<> inline EPointerEvents CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueAll:
return PE_ALL;
case CSSValueAuto:
@@ -3087,30 +2963,28 @@ template<> inline EPointerEvents CSSPrimitiveValue::convertTo() const
return PE_ALL;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontDescription::Kerning kerning)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(FontDescription::Kerning kerning)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (kerning) {
case FontDescription::AutoKerning:
- m_value.valueID = CSSValueAuto;
+ m_valueID = CSSValueAuto;
return;
case FontDescription::NormalKerning:
- m_value.valueID = CSSValueNormal;
+ m_valueID = CSSValueNormal;
return;
case FontDescription::NoneKerning:
- m_value.valueID = CSSValueNone;
+ m_valueID = CSSValueNone;
return;
}
ASSERT_NOT_REACHED();
- m_value.valueID = CSSValueAuto;
+ m_valueID = CSSValueAuto;
}
-template<> inline FontDescription::Kerning CSSPrimitiveValue::convertTo() const
+template<> inline FontDescription::Kerning CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueAuto:
return FontDescription::AutoKerning;
case CSSValueNormal:
@@ -3125,32 +2999,31 @@ template<> inline FontDescription::Kerning CSSPrimitiveValue::convertTo() const
return FontDescription::AutoKerning;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ObjectFit fit)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(ObjectFit fit)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (fit) {
case ObjectFitFill:
- m_value.valueID = CSSValueFill;
+ m_valueID = CSSValueFill;
break;
case ObjectFitContain:
- m_value.valueID = CSSValueContain;
+ m_valueID = CSSValueContain;
break;
case ObjectFitCover:
- m_value.valueID = CSSValueCover;
+ m_valueID = CSSValueCover;
break;
case ObjectFitNone:
- m_value.valueID = CSSValueNone;
+ m_valueID = CSSValueNone;
break;
case ObjectFitScaleDown:
- m_value.valueID = CSSValueScaleDown;
+ m_valueID = CSSValueScaleDown;
break;
}
}
-template<> inline ObjectFit CSSPrimitiveValue::convertTo() const
+template<> inline ObjectFit CSSIdentifierValue::convertTo() const
{
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueFill:
return ObjectFitFill;
case CSSValueContain:
@@ -3167,19 +3040,18 @@ template<> inline ObjectFit CSSPrimitiveValue::convertTo() const
}
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFillSizeType fillSize)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(EFillSizeType fillSize)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (fillSize) {
case Contain:
- m_value.valueID = CSSValueContain;
+ m_valueID = CSSValueContain;
break;
case Cover:
- m_value.valueID = CSSValueCover;
+ m_valueID = CSSValueCover;
break;
case SizeNone:
- m_value.valueID = CSSValueNone;
+ m_valueID = CSSValueNone;
break;
case SizeLength:
default:
@@ -3187,33 +3059,31 @@ template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFillSizeType fillSize)
}
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontSmoothingMode smoothing)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(FontSmoothingMode smoothing)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (smoothing) {
case AutoSmoothing:
- m_value.valueID = CSSValueAuto;
+ m_valueID = CSSValueAuto;
return;
case NoSmoothing:
- m_value.valueID = CSSValueNone;
+ m_valueID = CSSValueNone;
return;
case Antialiased:
- m_value.valueID = CSSValueAntialiased;
+ m_valueID = CSSValueAntialiased;
return;
case SubpixelAntialiased:
- m_value.valueID = CSSValueSubpixelAntialiased;
+ m_valueID = CSSValueSubpixelAntialiased;
return;
}
ASSERT_NOT_REACHED();
- m_value.valueID = CSSValueAuto;
+ m_valueID = CSSValueAuto;
}
-template<> inline FontSmoothingMode CSSPrimitiveValue::convertTo() const
+template<> inline FontSmoothingMode CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueAuto:
return AutoSmoothing;
case CSSValueNone:
@@ -3230,48 +3100,46 @@ template<> inline FontSmoothingMode CSSPrimitiveValue::convertTo() const
return AutoSmoothing;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontWeight weight)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(FontWeight weight)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (weight) {
case FontWeight900:
- m_value.valueID = CSSValue900;
+ m_valueID = CSSValue900;
return;
case FontWeight800:
- m_value.valueID = CSSValue800;
+ m_valueID = CSSValue800;
return;
case FontWeight700:
- m_value.valueID = CSSValueBold;
+ m_valueID = CSSValueBold;
return;
case FontWeight600:
- m_value.valueID = CSSValue600;
+ m_valueID = CSSValue600;
return;
case FontWeight500:
- m_value.valueID = CSSValue500;
+ m_valueID = CSSValue500;
return;
case FontWeight400:
- m_value.valueID = CSSValueNormal;
+ m_valueID = CSSValueNormal;
return;
case FontWeight300:
- m_value.valueID = CSSValue300;
+ m_valueID = CSSValue300;
return;
case FontWeight200:
- m_value.valueID = CSSValue200;
+ m_valueID = CSSValue200;
return;
case FontWeight100:
- m_value.valueID = CSSValue100;
+ m_valueID = CSSValue100;
return;
}
ASSERT_NOT_REACHED();
- m_value.valueID = CSSValueNormal;
+ m_valueID = CSSValueNormal;
}
-template<> inline FontWeight CSSPrimitiveValue::convertTo() const
+template<> inline FontWeight CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueBold:
return FontWeightBold;
case CSSValueNormal:
@@ -3302,30 +3170,28 @@ template<> inline FontWeight CSSPrimitiveValue::convertTo() const
return FontWeightNormal;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontStyle italic)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(FontStyle italic)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (italic) {
case FontStyleNormal:
- m_value.valueID = CSSValueNormal;
+ m_valueID = CSSValueNormal;
return;
case FontStyleOblique:
- m_value.valueID = CSSValueOblique;
+ m_valueID = CSSValueOblique;
return;
case FontStyleItalic:
- m_value.valueID = CSSValueItalic;
+ m_valueID = CSSValueItalic;
return;
}
ASSERT_NOT_REACHED();
- m_value.valueID = CSSValueNormal;
+ m_valueID = CSSValueNormal;
}
-template<> inline FontStyle CSSPrimitiveValue::convertTo() const
+template<> inline FontStyle CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueOblique:
return FontStyleOblique;
case CSSValueItalic:
@@ -3339,48 +3205,46 @@ template<> inline FontStyle CSSPrimitiveValue::convertTo() const
return FontStyleNormal;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontStretch stretch)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(FontStretch stretch)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (stretch) {
case FontStretchUltraCondensed:
- m_value.valueID = CSSValueUltraCondensed;
+ m_valueID = CSSValueUltraCondensed;
return;
case FontStretchExtraCondensed:
- m_value.valueID = CSSValueExtraCondensed;
+ m_valueID = CSSValueExtraCondensed;
return;
case FontStretchCondensed:
- m_value.valueID = CSSValueCondensed;
+ m_valueID = CSSValueCondensed;
return;
case FontStretchSemiCondensed:
- m_value.valueID = CSSValueSemiCondensed;
+ m_valueID = CSSValueSemiCondensed;
return;
case FontStretchNormal:
- m_value.valueID = CSSValueNormal;
+ m_valueID = CSSValueNormal;
return;
case FontStretchSemiExpanded:
- m_value.valueID = CSSValueSemiExpanded;
+ m_valueID = CSSValueSemiExpanded;
return;
case FontStretchExpanded:
- m_value.valueID = CSSValueExpanded;
+ m_valueID = CSSValueExpanded;
return;
case FontStretchExtraExpanded:
- m_value.valueID = CSSValueExtraExpanded;
+ m_valueID = CSSValueExtraExpanded;
return;
case FontStretchUltraExpanded:
- m_value.valueID = CSSValueUltraExpanded;
+ m_valueID = CSSValueUltraExpanded;
return;
}
ASSERT_NOT_REACHED();
- m_value.valueID = CSSValueNormal;
+ m_valueID = CSSValueNormal;
}
-template<> inline FontStretch CSSPrimitiveValue::convertTo() const
+template<> inline FontStretch CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueUltraCondensed:
return FontStretchUltraCondensed;
case CSSValueExtraCondensed:
@@ -3407,30 +3271,28 @@ template<> inline FontStretch CSSPrimitiveValue::convertTo() const
return FontStretchNormal;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextRenderingMode e)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(TextRenderingMode e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
case AutoTextRendering:
- m_value.valueID = CSSValueAuto;
+ m_valueID = CSSValueAuto;
break;
case OptimizeSpeed:
- m_value.valueID = CSSValueOptimizeSpeed;
+ m_valueID = CSSValueOptimizeSpeed;
break;
case OptimizeLegibility:
- m_value.valueID = CSSValueOptimizeLegibility;
+ m_valueID = CSSValueOptimizeLegibility;
break;
case GeometricPrecision:
- m_value.valueID = CSSValueGeometricPrecision;
+ m_valueID = CSSValueGeometricPrecision;
break;
}
}
-template<> inline TextRenderingMode CSSPrimitiveValue::convertTo() const
+template<> inline TextRenderingMode CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueAuto:
return AutoTextRendering;
case CSSValueOptimizeSpeed:
@@ -3447,36 +3309,34 @@ template<> inline TextRenderingMode CSSPrimitiveValue::convertTo() const
return AutoTextRendering;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ESpeak e)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(ESpeak e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
case SpeakNone:
- m_value.valueID = CSSValueNone;
+ m_valueID = CSSValueNone;
break;
case SpeakNormal:
- m_value.valueID = CSSValueNormal;
+ m_valueID = CSSValueNormal;
break;
case SpeakSpellOut:
- m_value.valueID = CSSValueSpellOut;
+ m_valueID = CSSValueSpellOut;
break;
case SpeakDigits:
- m_value.valueID = CSSValueDigits;
+ m_valueID = CSSValueDigits;
break;
case SpeakLiteralPunctuation:
- m_value.valueID = CSSValueLiteralPunctuation;
+ m_valueID = CSSValueLiteralPunctuation;
break;
case SpeakNoPunctuation:
- m_value.valueID = CSSValueNoPunctuation;
+ m_valueID = CSSValueNoPunctuation;
break;
}
}
-template<> inline Order CSSPrimitiveValue::convertTo() const
+template<> inline Order CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueLogical:
return LogicalOrder;
case CSSValueVisual:
@@ -3489,24 +3349,22 @@ template<> inline Order CSSPrimitiveValue::convertTo() const
return LogicalOrder;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(Order e)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(Order e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
case LogicalOrder:
- m_value.valueID = CSSValueLogical;
+ m_valueID = CSSValueLogical;
break;
case VisualOrder:
- m_value.valueID = CSSValueVisual;
+ m_valueID = CSSValueVisual;
break;
}
}
-template<> inline ESpeak CSSPrimitiveValue::convertTo() const
+template<> inline ESpeak CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueNone:
return SpeakNone;
case CSSValueNormal:
@@ -3527,66 +3385,64 @@ template<> inline ESpeak CSSPrimitiveValue::convertTo() const
return SpeakNormal;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(WebBlendMode blendMode)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(WebBlendMode blendMode)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (blendMode) {
case WebBlendModeNormal:
- m_value.valueID = CSSValueNormal;
+ m_valueID = CSSValueNormal;
break;
case WebBlendModeMultiply:
- m_value.valueID = CSSValueMultiply;
+ m_valueID = CSSValueMultiply;
break;
case WebBlendModeScreen:
- m_value.valueID = CSSValueScreen;
+ m_valueID = CSSValueScreen;
break;
case WebBlendModeOverlay:
- m_value.valueID = CSSValueOverlay;
+ m_valueID = CSSValueOverlay;
break;
case WebBlendModeDarken:
- m_value.valueID = CSSValueDarken;
+ m_valueID = CSSValueDarken;
break;
case WebBlendModeLighten:
- m_value.valueID = CSSValueLighten;
+ m_valueID = CSSValueLighten;
break;
case WebBlendModeColorDodge:
- m_value.valueID = CSSValueColorDodge;
+ m_valueID = CSSValueColorDodge;
break;
case WebBlendModeColorBurn:
- m_value.valueID = CSSValueColorBurn;
+ m_valueID = CSSValueColorBurn;
break;
case WebBlendModeHardLight:
- m_value.valueID = CSSValueHardLight;
+ m_valueID = CSSValueHardLight;
break;
case WebBlendModeSoftLight:
- m_value.valueID = CSSValueSoftLight;
+ m_valueID = CSSValueSoftLight;
break;
case WebBlendModeDifference:
- m_value.valueID = CSSValueDifference;
+ m_valueID = CSSValueDifference;
break;
case WebBlendModeExclusion:
- m_value.valueID = CSSValueExclusion;
+ m_valueID = CSSValueExclusion;
break;
case WebBlendModeHue:
- m_value.valueID = CSSValueHue;
+ m_valueID = CSSValueHue;
break;
case WebBlendModeSaturation:
- m_value.valueID = CSSValueSaturation;
+ m_valueID = CSSValueSaturation;
break;
case WebBlendModeColor:
- m_value.valueID = CSSValueColor;
+ m_valueID = CSSValueColor;
break;
case WebBlendModeLuminosity:
- m_value.valueID = CSSValueLuminosity;
+ m_valueID = CSSValueLuminosity;
break;
}
}
-template<> inline WebBlendMode CSSPrimitiveValue::convertTo() const
+template<> inline WebBlendMode CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueNormal:
return WebBlendModeNormal;
case CSSValueMultiply:
@@ -3627,27 +3483,25 @@ template<> inline WebBlendMode CSSPrimitiveValue::convertTo() const
return WebBlendModeNormal;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineCap e)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(LineCap e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
case ButtCap:
- m_value.valueID = CSSValueButt;
+ m_valueID = CSSValueButt;
break;
case RoundCap:
- m_value.valueID = CSSValueRound;
+ m_valueID = CSSValueRound;
break;
case SquareCap:
- m_value.valueID = CSSValueSquare;
+ m_valueID = CSSValueSquare;
break;
}
}
-template<> inline LineCap CSSPrimitiveValue::convertTo() const
+template<> inline LineCap CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueButt:
return ButtCap;
case CSSValueRound:
@@ -3662,27 +3516,25 @@ template<> inline LineCap CSSPrimitiveValue::convertTo() const
return ButtCap;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineJoin e)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(LineJoin e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
case MiterJoin:
- m_value.valueID = CSSValueMiter;
+ m_valueID = CSSValueMiter;
break;
case RoundJoin:
- m_value.valueID = CSSValueRound;
+ m_valueID = CSSValueRound;
break;
case BevelJoin:
- m_value.valueID = CSSValueBevel;
+ m_valueID = CSSValueBevel;
break;
}
}
-template<> inline LineJoin CSSPrimitiveValue::convertTo() const
+template<> inline LineJoin CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueMiter:
return MiterJoin;
case CSSValueRound:
@@ -3697,24 +3549,22 @@ template<> inline LineJoin CSSPrimitiveValue::convertTo() const
return MiterJoin;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(WindRule e)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(WindRule e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
case RULE_NONZERO:
- m_value.valueID = CSSValueNonzero;
+ m_valueID = CSSValueNonzero;
break;
case RULE_EVENODD:
- m_value.valueID = CSSValueEvenodd;
+ m_valueID = CSSValueEvenodd;
break;
}
}
-template<> inline WindRule CSSPrimitiveValue::convertTo() const
+template<> inline WindRule CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueNonzero:
return RULE_NONZERO;
case CSSValueEvenodd:
@@ -3728,54 +3578,52 @@ template<> inline WindRule CSSPrimitiveValue::convertTo() const
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EAlignmentBaseline e)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(EAlignmentBaseline e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
case AB_AUTO:
- m_value.valueID = CSSValueAuto;
+ m_valueID = CSSValueAuto;
break;
case AB_BASELINE:
- m_value.valueID = CSSValueBaseline;
+ m_valueID = CSSValueBaseline;
break;
case AB_BEFORE_EDGE:
- m_value.valueID = CSSValueBeforeEdge;
+ m_valueID = CSSValueBeforeEdge;
break;
case AB_TEXT_BEFORE_EDGE:
- m_value.valueID = CSSValueTextBeforeEdge;
+ m_valueID = CSSValueTextBeforeEdge;
break;
case AB_MIDDLE:
- m_value.valueID = CSSValueMiddle;
+ m_valueID = CSSValueMiddle;
break;
case AB_CENTRAL:
- m_value.valueID = CSSValueCentral;
+ m_valueID = CSSValueCentral;
break;
case AB_AFTER_EDGE:
- m_value.valueID = CSSValueAfterEdge;
+ m_valueID = CSSValueAfterEdge;
break;
case AB_TEXT_AFTER_EDGE:
- m_value.valueID = CSSValueTextAfterEdge;
+ m_valueID = CSSValueTextAfterEdge;
break;
case AB_IDEOGRAPHIC:
- m_value.valueID = CSSValueIdeographic;
+ m_valueID = CSSValueIdeographic;
break;
case AB_ALPHABETIC:
- m_value.valueID = CSSValueAlphabetic;
+ m_valueID = CSSValueAlphabetic;
break;
case AB_HANGING:
- m_value.valueID = CSSValueHanging;
+ m_valueID = CSSValueHanging;
break;
case AB_MATHEMATICAL:
- m_value.valueID = CSSValueMathematical;
+ m_valueID = CSSValueMathematical;
break;
}
}
-template<> inline EAlignmentBaseline CSSPrimitiveValue::convertTo() const
+template<> inline EAlignmentBaseline CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueAuto:
return AB_AUTO;
case CSSValueBaseline:
@@ -3808,24 +3656,22 @@ template<> inline EAlignmentBaseline CSSPrimitiveValue::convertTo() const
return AB_AUTO;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBorderCollapse e)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(EBorderCollapse e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
case BorderCollapseSeparate:
- m_value.valueID = CSSValueSeparate;
+ m_valueID = CSSValueSeparate;
break;
case BorderCollapseCollapse:
- m_value.valueID = CSSValueCollapse;
+ m_valueID = CSSValueCollapse;
break;
}
}
-template<> inline EBorderCollapse CSSPrimitiveValue::convertTo() const
+template<> inline EBorderCollapse CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueSeparate:
return BorderCollapseSeparate;
case CSSValueCollapse:
@@ -3838,33 +3684,31 @@ template<> inline EBorderCollapse CSSPrimitiveValue::convertTo() const
return BorderCollapseSeparate;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EImageRendering e)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(EImageRendering e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
case ImageRenderingAuto:
- m_value.valueID = CSSValueAuto;
+ m_valueID = CSSValueAuto;
break;
case ImageRenderingOptimizeSpeed:
- m_value.valueID = CSSValueOptimizeSpeed;
+ m_valueID = CSSValueOptimizeSpeed;
break;
case ImageRenderingOptimizeQuality:
- m_value.valueID = CSSValueOptimizeQuality;
+ m_valueID = CSSValueOptimizeQuality;
break;
case ImageRenderingPixelated:
- m_value.valueID = CSSValuePixelated;
+ m_valueID = CSSValuePixelated;
break;
case ImageRenderingOptimizeContrast:
- m_value.valueID = CSSValueWebkitOptimizeContrast;
+ m_valueID = CSSValueWebkitOptimizeContrast;
break;
}
}
-template<> inline EImageRendering CSSPrimitiveValue::convertTo() const
+template<> inline EImageRendering CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueAuto:
return ImageRenderingAuto;
case CSSValueOptimizeSpeed:
@@ -3883,24 +3727,22 @@ template<> inline EImageRendering CSSPrimitiveValue::convertTo() const
return ImageRenderingAuto;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETransformStyle3D e)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(ETransformStyle3D e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
case TransformStyle3DFlat:
- m_value.valueID = CSSValueFlat;
+ m_valueID = CSSValueFlat;
break;
case TransformStyle3DPreserve3D:
- m_value.valueID = CSSValuePreserve3d;
+ m_valueID = CSSValuePreserve3d;
break;
}
}
-template<> inline ETransformStyle3D CSSPrimitiveValue::convertTo() const
+template<> inline ETransformStyle3D CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueFlat:
return TransformStyle3DFlat;
case CSSValuePreserve3d:
@@ -3913,27 +3755,25 @@ template<> inline ETransformStyle3D CSSPrimitiveValue::convertTo() const
return TransformStyle3DFlat;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBufferedRendering e)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(EBufferedRendering e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
case BR_AUTO:
- m_value.valueID = CSSValueAuto;
+ m_valueID = CSSValueAuto;
break;
case BR_DYNAMIC:
- m_value.valueID = CSSValueDynamic;
+ m_valueID = CSSValueDynamic;
break;
case BR_STATIC:
- m_value.valueID = CSSValueStatic;
+ m_valueID = CSSValueStatic;
break;
}
}
-template<> inline EBufferedRendering CSSPrimitiveValue::convertTo() const
+template<> inline EBufferedRendering CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueAuto:
return BR_AUTO;
case CSSValueDynamic:
@@ -3948,27 +3788,25 @@ template<> inline EBufferedRendering CSSPrimitiveValue::convertTo() const
return BR_AUTO;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EColorInterpolation e)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(EColorInterpolation e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
case CI_AUTO:
- m_value.valueID = CSSValueAuto;
+ m_valueID = CSSValueAuto;
break;
case CI_SRGB:
- m_value.valueID = CSSValueSRGB;
+ m_valueID = CSSValueSRGB;
break;
case CI_LINEARRGB:
- m_value.valueID = CSSValueLinearRGB;
+ m_valueID = CSSValueLinearRGB;
break;
}
}
-template<> inline EColorInterpolation CSSPrimitiveValue::convertTo() const
+template<> inline EColorInterpolation CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueSRGB:
return CI_SRGB;
case CSSValueLinearRGB:
@@ -3983,27 +3821,25 @@ template<> inline EColorInterpolation CSSPrimitiveValue::convertTo() const
return CI_AUTO;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EColorRendering e)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(EColorRendering e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
case CR_AUTO:
- m_value.valueID = CSSValueAuto;
+ m_valueID = CSSValueAuto;
break;
case CR_OPTIMIZESPEED:
- m_value.valueID = CSSValueOptimizeSpeed;
+ m_valueID = CSSValueOptimizeSpeed;
break;
case CR_OPTIMIZEQUALITY:
- m_value.valueID = CSSValueOptimizeQuality;
+ m_valueID = CSSValueOptimizeQuality;
break;
}
}
-template<> inline EColorRendering CSSPrimitiveValue::convertTo() const
+template<> inline EColorRendering CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueOptimizeSpeed:
return CR_OPTIMIZESPEED;
case CSSValueOptimizeQuality:
@@ -4018,54 +3854,52 @@ template<> inline EColorRendering CSSPrimitiveValue::convertTo() const
return CR_AUTO;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EDominantBaseline e)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(EDominantBaseline e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
case DB_AUTO:
- m_value.valueID = CSSValueAuto;
+ m_valueID = CSSValueAuto;
break;
case DB_USE_SCRIPT:
- m_value.valueID = CSSValueUseScript;
+ m_valueID = CSSValueUseScript;
break;
case DB_NO_CHANGE:
- m_value.valueID = CSSValueNoChange;
+ m_valueID = CSSValueNoChange;
break;
case DB_RESET_SIZE:
- m_value.valueID = CSSValueResetSize;
+ m_valueID = CSSValueResetSize;
break;
case DB_CENTRAL:
- m_value.valueID = CSSValueCentral;
+ m_valueID = CSSValueCentral;
break;
case DB_MIDDLE:
- m_value.valueID = CSSValueMiddle;
+ m_valueID = CSSValueMiddle;
break;
case DB_TEXT_BEFORE_EDGE:
- m_value.valueID = CSSValueTextBeforeEdge;
+ m_valueID = CSSValueTextBeforeEdge;
break;
case DB_TEXT_AFTER_EDGE:
- m_value.valueID = CSSValueTextAfterEdge;
+ m_valueID = CSSValueTextAfterEdge;
break;
case DB_IDEOGRAPHIC:
- m_value.valueID = CSSValueIdeographic;
+ m_valueID = CSSValueIdeographic;
break;
case DB_ALPHABETIC:
- m_value.valueID = CSSValueAlphabetic;
+ m_valueID = CSSValueAlphabetic;
break;
case DB_HANGING:
- m_value.valueID = CSSValueHanging;
+ m_valueID = CSSValueHanging;
break;
case DB_MATHEMATICAL:
- m_value.valueID = CSSValueMathematical;
+ m_valueID = CSSValueMathematical;
break;
}
}
-template<> inline EDominantBaseline CSSPrimitiveValue::convertTo() const
+template<> inline EDominantBaseline CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueAuto:
return DB_AUTO;
case CSSValueUseScript:
@@ -4098,30 +3932,28 @@ template<> inline EDominantBaseline CSSPrimitiveValue::convertTo() const
return DB_AUTO;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EShapeRendering e)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(EShapeRendering e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
case SR_AUTO:
- m_value.valueID = CSSValueAuto;
+ m_valueID = CSSValueAuto;
break;
case SR_OPTIMIZESPEED:
- m_value.valueID = CSSValueOptimizeSpeed;
+ m_valueID = CSSValueOptimizeSpeed;
break;
case SR_CRISPEDGES:
- m_value.valueID = CSSValueCrispEdges;
+ m_valueID = CSSValueCrispEdges;
break;
case SR_GEOMETRICPRECISION:
- m_value.valueID = CSSValueGeometricPrecision;
+ m_valueID = CSSValueGeometricPrecision;
break;
}
}
-template<> inline EShapeRendering CSSPrimitiveValue::convertTo() const
+template<> inline EShapeRendering CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueAuto:
return SR_AUTO;
case CSSValueOptimizeSpeed:
@@ -4138,27 +3970,25 @@ template<> inline EShapeRendering CSSPrimitiveValue::convertTo() const
return SR_AUTO;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETextAnchor e)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(ETextAnchor e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
case TA_START:
- m_value.valueID = CSSValueStart;
+ m_valueID = CSSValueStart;
break;
case TA_MIDDLE:
- m_value.valueID = CSSValueMiddle;
+ m_valueID = CSSValueMiddle;
break;
case TA_END:
- m_value.valueID = CSSValueEnd;
+ m_valueID = CSSValueEnd;
break;
}
}
-template<> inline ETextAnchor CSSPrimitiveValue::convertTo() const
+template<> inline ETextAnchor CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueStart:
return TA_START;
case CSSValueMiddle:
@@ -4173,24 +4003,22 @@ template<> inline ETextAnchor CSSPrimitiveValue::convertTo() const
return TA_START;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EVectorEffect e)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(EVectorEffect e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
case VE_NONE:
- m_value.valueID = CSSValueNone;
+ m_valueID = CSSValueNone;
break;
case VE_NON_SCALING_STROKE:
- m_value.valueID = CSSValueNonScalingStroke;
+ m_valueID = CSSValueNonScalingStroke;
break;
}
}
-template<> inline EVectorEffect CSSPrimitiveValue::convertTo() const
+template<> inline EVectorEffect CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueNone:
return VE_NONE;
case CSSValueNonScalingStroke:
@@ -4203,31 +4031,29 @@ template<> inline EVectorEffect CSSPrimitiveValue::convertTo() const
return VE_NONE;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EPaintOrderType e)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(EPaintOrderType e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
case PT_FILL:
- m_value.valueID = CSSValueFill;
+ m_valueID = CSSValueFill;
break;
case PT_STROKE:
- m_value.valueID = CSSValueStroke;
+ m_valueID = CSSValueStroke;
break;
case PT_MARKERS:
- m_value.valueID = CSSValueMarkers;
+ m_valueID = CSSValueMarkers;
break;
default:
ASSERT_NOT_REACHED();
- m_value.valueID = CSSValueFill;
+ m_valueID = CSSValueFill;
break;
}
}
-template<> inline EPaintOrderType CSSPrimitiveValue::convertTo() const
+template<> inline EPaintOrderType CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueFill:
return PT_FILL;
case CSSValueStroke:
@@ -4242,24 +4068,22 @@ template<> inline EPaintOrderType CSSPrimitiveValue::convertTo() const
return PT_NONE;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EMaskType e)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(EMaskType e)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (e) {
case MT_LUMINANCE:
- m_value.valueID = CSSValueLuminance;
+ m_valueID = CSSValueLuminance;
break;
case MT_ALPHA:
- m_value.valueID = CSSValueAlpha;
+ m_valueID = CSSValueAlpha;
break;
}
}
-template<> inline EMaskType CSSPrimitiveValue::convertTo() const
+template<> inline EMaskType CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueLuminance:
return MT_LUMINANCE;
case CSSValueAlpha:
@@ -4272,10 +4096,9 @@ template<> inline EMaskType CSSPrimitiveValue::convertTo() const
return MT_LUMINANCE;
}
-template<> inline TouchAction CSSPrimitiveValue::convertTo() const
+template<> inline TouchAction CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueNone:
return TouchActionNone;
case CSSValueAuto:
@@ -4304,24 +4127,22 @@ template<> inline TouchAction CSSPrimitiveValue::convertTo() const
return TouchActionNone;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EIsolation i)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(EIsolation i)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (i) {
case IsolationAuto:
- m_value.valueID = CSSValueAuto;
+ m_valueID = CSSValueAuto;
break;
case IsolationIsolate:
- m_value.valueID = CSSValueIsolate;
+ m_valueID = CSSValueIsolate;
break;
}
}
-template<> inline EIsolation CSSPrimitiveValue::convertTo() const
+template<> inline EIsolation CSSIdentifierValue::convertTo() const
{
- ASSERT(isValueID());
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueAuto:
return IsolationAuto;
case CSSValueIsolate:
@@ -4334,22 +4155,21 @@ template<> inline EIsolation CSSPrimitiveValue::convertTo() const
return IsolationAuto;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(CSSBoxType cssBox)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(CSSBoxType cssBox)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (cssBox) {
case MarginBox:
- m_value.valueID = CSSValueMarginBox;
+ m_valueID = CSSValueMarginBox;
break;
case BorderBox:
- m_value.valueID = CSSValueBorderBox;
+ m_valueID = CSSValueBorderBox;
break;
case PaddingBox:
- m_value.valueID = CSSValuePaddingBox;
+ m_valueID = CSSValuePaddingBox;
break;
case ContentBox:
- m_value.valueID = CSSValueContentBox;
+ m_valueID = CSSValueContentBox;
break;
case BoxMissing:
// The missing box should convert to a null primitive value.
@@ -4357,7 +4177,7 @@ template<> inline CSSPrimitiveValue::CSSPrimitiveValue(CSSBoxType cssBox)
}
}
-template<> inline CSSBoxType CSSPrimitiveValue::convertTo() const
+template<> inline CSSBoxType CSSIdentifierValue::convertTo() const
{
switch (getValueID()) {
case CSSValueMarginBox:
@@ -4375,61 +4195,60 @@ template<> inline CSSBoxType CSSPrimitiveValue::convertTo() const
return ContentBox;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ItemPosition itemPosition)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(ItemPosition itemPosition)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (itemPosition) {
case ItemPositionAuto:
// The 'auto' values might have been already resolved.
NOTREACHED();
- m_value.valueID = CSSValueNormal;
+ m_valueID = CSSValueNormal;
break;
case ItemPositionNormal:
- m_value.valueID = CSSValueNormal;
+ m_valueID = CSSValueNormal;
break;
case ItemPositionStretch:
- m_value.valueID = CSSValueStretch;
+ m_valueID = CSSValueStretch;
break;
case ItemPositionBaseline:
- m_value.valueID = CSSValueBaseline;
+ m_valueID = CSSValueBaseline;
break;
case ItemPositionLastBaseline:
- m_value.valueID = CSSValueLastBaseline;
+ m_valueID = CSSValueLastBaseline;
break;
case ItemPositionCenter:
- m_value.valueID = CSSValueCenter;
+ m_valueID = CSSValueCenter;
break;
case ItemPositionStart:
- m_value.valueID = CSSValueStart;
+ m_valueID = CSSValueStart;
break;
case ItemPositionEnd:
- m_value.valueID = CSSValueEnd;
+ m_valueID = CSSValueEnd;
break;
case ItemPositionSelfStart:
- m_value.valueID = CSSValueSelfStart;
+ m_valueID = CSSValueSelfStart;
break;
case ItemPositionSelfEnd:
- m_value.valueID = CSSValueSelfEnd;
+ m_valueID = CSSValueSelfEnd;
break;
case ItemPositionFlexStart:
- m_value.valueID = CSSValueFlexStart;
+ m_valueID = CSSValueFlexStart;
break;
case ItemPositionFlexEnd:
- m_value.valueID = CSSValueFlexEnd;
+ m_valueID = CSSValueFlexEnd;
break;
case ItemPositionLeft:
- m_value.valueID = CSSValueLeft;
+ m_valueID = CSSValueLeft;
break;
case ItemPositionRight:
- m_value.valueID = CSSValueRight;
+ m_valueID = CSSValueRight;
break;
}
}
-template<> inline ItemPosition CSSPrimitiveValue::convertTo() const
+template<> inline ItemPosition CSSIdentifierValue::convertTo() const
{
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueAuto:
return ItemPositionAuto;
case CSSValueNormal:
@@ -4465,47 +4284,46 @@ template<> inline ItemPosition CSSPrimitiveValue::convertTo() const
return ItemPositionAuto;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ContentPosition contentPosition)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(ContentPosition contentPosition)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (contentPosition) {
case ContentPositionNormal:
- m_value.valueID = CSSValueNormal;
+ m_valueID = CSSValueNormal;
break;
case ContentPositionBaseline:
- m_value.valueID = CSSValueBaseline;
+ m_valueID = CSSValueBaseline;
break;
case ContentPositionLastBaseline:
- m_value.valueID = CSSValueLastBaseline;
+ m_valueID = CSSValueLastBaseline;
break;
case ContentPositionCenter:
- m_value.valueID = CSSValueCenter;
+ m_valueID = CSSValueCenter;
break;
case ContentPositionStart:
- m_value.valueID = CSSValueStart;
+ m_valueID = CSSValueStart;
break;
case ContentPositionEnd:
- m_value.valueID = CSSValueEnd;
+ m_valueID = CSSValueEnd;
break;
case ContentPositionFlexStart:
- m_value.valueID = CSSValueFlexStart;
+ m_valueID = CSSValueFlexStart;
break;
case ContentPositionFlexEnd:
- m_value.valueID = CSSValueFlexEnd;
+ m_valueID = CSSValueFlexEnd;
break;
case ContentPositionLeft:
- m_value.valueID = CSSValueLeft;
+ m_valueID = CSSValueLeft;
break;
case ContentPositionRight:
- m_value.valueID = CSSValueRight;
+ m_valueID = CSSValueRight;
break;
}
}
-template<> inline ContentPosition CSSPrimitiveValue::convertTo() const
+template<> inline ContentPosition CSSIdentifierValue::convertTo() const
{
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueNormal:
return ContentPositionNormal;
case CSSValueBaseline:
@@ -4533,32 +4351,31 @@ template<> inline ContentPosition CSSPrimitiveValue::convertTo() const
return ContentPositionNormal;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ContentDistributionType contentDistribution)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(ContentDistributionType contentDistribution)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (contentDistribution) {
case ContentDistributionDefault:
- m_value.valueID = CSSValueDefault;
+ m_valueID = CSSValueDefault;
break;
case ContentDistributionSpaceBetween:
- m_value.valueID = CSSValueSpaceBetween;
+ m_valueID = CSSValueSpaceBetween;
break;
case ContentDistributionSpaceAround:
- m_value.valueID = CSSValueSpaceAround;
+ m_valueID = CSSValueSpaceAround;
break;
case ContentDistributionSpaceEvenly:
- m_value.valueID = CSSValueSpaceEvenly;
+ m_valueID = CSSValueSpaceEvenly;
break;
case ContentDistributionStretch:
- m_value.valueID = CSSValueStretch;
+ m_valueID = CSSValueStretch;
break;
}
}
-template<> inline ContentDistributionType CSSPrimitiveValue::convertTo() const
+template<> inline ContentDistributionType CSSIdentifierValue::convertTo() const
{
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueSpaceBetween:
return ContentDistributionSpaceBetween;
case CSSValueSpaceAround:
@@ -4574,26 +4391,25 @@ template<> inline ContentDistributionType CSSPrimitiveValue::convertTo() const
return ContentDistributionStretch;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(OverflowAlignment overflowAlignment)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(OverflowAlignment overflowAlignment)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (overflowAlignment) {
case OverflowAlignmentDefault:
- m_value.valueID = CSSValueDefault;
+ m_valueID = CSSValueDefault;
break;
case OverflowAlignmentUnsafe:
- m_value.valueID = CSSValueUnsafe;
+ m_valueID = CSSValueUnsafe;
break;
case OverflowAlignmentSafe:
- m_value.valueID = CSSValueSafe;
+ m_valueID = CSSValueSafe;
break;
}
}
-template<> inline OverflowAlignment CSSPrimitiveValue::convertTo() const
+template<> inline OverflowAlignment CSSIdentifierValue::convertTo() const
{
- switch (m_value.valueID) {
+ switch (m_valueID) {
case CSSValueUnsafe:
return OverflowAlignmentUnsafe;
case CSSValueSafe:
@@ -4605,16 +4421,15 @@ template<> inline OverflowAlignment CSSPrimitiveValue::convertTo() const
return OverflowAlignmentUnsafe;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ScrollBehavior behavior)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(ScrollBehavior behavior)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (behavior) {
case ScrollBehaviorAuto:
- m_value.valueID = CSSValueAuto;
+ m_valueID = CSSValueAuto;
break;
case ScrollBehaviorSmooth:
- m_value.valueID = CSSValueSmooth;
+ m_valueID = CSSValueSmooth;
break;
case ScrollBehaviorInstant:
// Behavior 'instant' is only allowed in ScrollOptions arguments passed to
@@ -4623,7 +4438,7 @@ template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ScrollBehavior behavior)
}
}
-template<> inline ScrollBehavior CSSPrimitiveValue::convertTo() const
+template<> inline ScrollBehavior CSSIdentifierValue::convertTo() const
{
switch (getValueID()) {
case CSSValueAuto:
@@ -4637,24 +4452,23 @@ template<> inline ScrollBehavior CSSPrimitiveValue::convertTo() const
return ScrollBehaviorAuto;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ScrollSnapType snapType)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(ScrollSnapType snapType)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (snapType) {
case ScrollSnapTypeNone:
- m_value.valueID = CSSValueNone;
+ m_valueID = CSSValueNone;
break;
case ScrollSnapTypeMandatory:
- m_value.valueID = CSSValueMandatory;
+ m_valueID = CSSValueMandatory;
break;
case ScrollSnapTypeProximity:
- m_value.valueID = CSSValueProximity;
+ m_valueID = CSSValueProximity;
break;
}
}
-template<> inline ScrollSnapType CSSPrimitiveValue::convertTo() const
+template<> inline ScrollSnapType CSSIdentifierValue::convertTo() const
{
switch (getValueID()) {
case CSSValueNone:
@@ -4670,36 +4484,35 @@ template<> inline ScrollSnapType CSSPrimitiveValue::convertTo() const
return ScrollSnapTypeNone;
}
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(Containment snapType)
- : CSSValue(PrimitiveClass)
+template<> inline CSSIdentifierValue::CSSIdentifierValue(Containment snapType)
+ : CSSValue(IdentifierClass)
{
- init(UnitType::ValueID);
switch (snapType) {
case ContainsNone:
- m_value.valueID = CSSValueNone;
+ m_valueID = CSSValueNone;
break;
case ContainsStrict:
- m_value.valueID = CSSValueStrict;
+ m_valueID = CSSValueStrict;
break;
case ContainsContent:
- m_value.valueID = CSSValueContent;
+ m_valueID = CSSValueContent;
break;
case ContainsPaint:
- m_value.valueID = CSSValuePaint;
+ m_valueID = CSSValuePaint;
break;
case ContainsStyle:
- m_value.valueID = CSSValueStyle;
+ m_valueID = CSSValueStyle;
break;
case ContainsLayout:
- m_value.valueID = CSSValueLayout;
+ m_valueID = CSSValueLayout;
break;
case ContainsSize:
- m_value.valueID = CSSValueSize;
+ m_valueID = CSSValueSize;
break;
}
}
-template<> inline Containment CSSPrimitiveValue::convertTo() const
+template<> inline Containment CSSIdentifierValue::convertTo() const
{
switch (getValueID()) {
case CSSValueNone:
« no previous file with comments | « third_party/WebKit/Source/core/css/CSSPrimitiveValue.cpp ('k') | third_party/WebKit/Source/core/css/CSSQuadValue.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698