--- a/layout/style/nsRuleNode.cpp
+++ b/layout/style/nsRuleNode.cpp
@@ -1334,22 +1334,18 @@ struct SetValueHelper : Conditional<IsEn
MOZ_ASSERT_UNREACHABLE("inappropriate unit");
}
};
// flags for SetValue - align values with SETCOORD_* constants
// where possible
-#define SETVAL_NORMAL 0x01 // N
-#define SETVAL_AUTO 0x02 // A
#define SETVAL_INTEGER 0x40 // I
#define SETVAL_ENUMERATED 0x80 // E
-#define SETVAL_NONE 0x100 // O
-#define SETVAL_SYSTEM_FONT 0x2000
#define SETVAL_UNSET_INHERIT 0x00400000
#define SETVAL_UNSET_INITIAL 0x00800000
// no caller cares whether aField was changed or not
template<typename FieldT, typename InitialT,
typename AutoT, typename NoneT, typename NormalT, typename SysFontT>
static void
SetValue(const nsCSSValue& aValue, FieldT& aField,
@@ -1391,42 +1387,30 @@ SetValue(const nsCSSValue& aValue, Field
if (aMask & SETVAL_INTEGER) {
Helper::SetIntegerValue(aField, aValue);
return;
}
break;
// remaining possibilities in descending order of frequency of use
case eCSSUnit_Auto:
- if (aMask & SETVAL_AUTO) {
- Helper::SetValue(aField, aAutoValue);
- return;
- }
- break;
+ Helper::SetValue(aField, aAutoValue);
+ return;
case eCSSUnit_None:
- if (aMask & SETVAL_NONE) {
- Helper::SetValue(aField, aNoneValue);
- return;
- }
- break;
+ Helper::SetValue(aField, aNoneValue);
+ return;
case eCSSUnit_Normal:
- if (aMask & SETVAL_NORMAL) {
- Helper::SetValue(aField, aNormalValue);
- return;
- }
- break;
+ Helper::SetValue(aField, aNormalValue);
+ return;
case eCSSUnit_System_Font:
- if (aMask & SETVAL_SYSTEM_FONT) {
- Helper::SetValue(aField, aSystemFontValue);
- return;
- }
- break;
+ Helper::SetValue(aField, aSystemFontValue);
+ return;
case eCSSUnit_Unset:
if (aMask & SETVAL_UNSET_INHERIT) {
aConditions.SetUncacheable();
aField = aParentValue;
return;
}
if (aMask & SETVAL_UNSET_INITIAL) {
@@ -3562,45 +3546,42 @@ nsRuleNode::SetFont(nsPresContext* aPres
if (aGenericFontID != kGenericFont_NONE) {
aFont->mGenericID = aGenericFontID;
}
// -moz-math-variant: enum, inherit, initial
SetValue(*aRuleData->ValueForMathVariant(), aFont->mMathVariant,
aConditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT,
- aParentFont->mMathVariant, NS_MATHML_MATHVARIANT_NONE,
- 0, 0, 0, 0);
+ aParentFont->mMathVariant, NS_MATHML_MATHVARIANT_NONE);
// -moz-math-display: enum, inherit, initial
SetValue(*aRuleData->ValueForMathDisplay(), aFont->mMathDisplay,
aConditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT,
- aParentFont->mMathDisplay, NS_MATHML_DISPLAYSTYLE_INLINE,
- 0, 0, 0, 0);
+ aParentFont->mMathDisplay, NS_MATHML_DISPLAYSTYLE_INLINE);
// font-smoothing: enum, inherit, initial
SetValue(*aRuleData->ValueForOsxFontSmoothing(),
aFont->mFont.smoothing, aConditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT,
aParentFont->mFont.smoothing,
- defaultVariableFont->smoothing,
- 0, 0, 0, 0);
+ defaultVariableFont->smoothing);
// font-style: enum, inherit, initial, -moz-system-font
if (aFont->mMathVariant != NS_MATHML_MATHVARIANT_NONE) {
// -moz-math-variant overrides font-style
aFont->mFont.style = NS_FONT_STYLE_NORMAL;
} else {
SetValue(*aRuleData->ValueForFontStyle(),
aFont->mFont.style, aConditions,
- SETVAL_ENUMERATED | SETVAL_SYSTEM_FONT | SETVAL_UNSET_INHERIT,
+ SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT,
aParentFont->mFont.style,
defaultVariableFont->style,
- 0, 0, 0, systemFont.style);
+ Unused, Unused, Unused, systemFont.style);
}
// font-weight: int, enum, inherit, initial, -moz-system-font
// special handling for enum
const nsCSSValue* weightValue = aRuleData->ValueForFontWeight();
if (aFont->mMathVariant != NS_MATHML_MATHVARIANT_NONE) {
// -moz-math-variant overrides font-weight
aFont->mFont.weight = NS_FONT_WEIGHT_NORMAL;
@@ -3633,28 +3614,28 @@ nsRuleNode::SetFont(nsPresContext* aPres
} else {
aFont->mFont.weight = 700;
}
break;
}
}
} else
SetValue(*weightValue, aFont->mFont.weight, aConditions,
- SETVAL_INTEGER | SETVAL_SYSTEM_FONT | SETVAL_UNSET_INHERIT,
+ SETVAL_INTEGER | SETVAL_UNSET_INHERIT,
aParentFont->mFont.weight,
defaultVariableFont->weight,
- 0, 0, 0, systemFont.weight);
+ Unused, Unused, Unused, systemFont.weight);
// font-stretch: enum, inherit, initial, -moz-system-font
SetValue(*aRuleData->ValueForFontStretch(),
aFont->mFont.stretch, aConditions,
- SETVAL_SYSTEM_FONT | SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT,
+ SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT,
aParentFont->mFont.stretch,
defaultVariableFont->stretch,
- 0, 0, 0, systemFont.stretch);
+ Unused, Unused, Unused, systemFont.stretch);
// Compute scriptlevel, scriptminsize and scriptsizemultiplier now so
// they're available for font-size computation.
// -moz-script-min-size: length
const nsCSSValue* scriptMinSizeValue = aRuleData->ValueForScriptMinSize();
if (scriptMinSizeValue->IsLengthUnit()) {
// scriptminsize in font units (em, ex) has to be interpreted relative
@@ -3699,29 +3680,28 @@ nsRuleNode::SetFont(nsPresContext* aPres
}
else if (eCSSUnit_Initial == scriptLevelValue->GetUnit()) {
aFont->mScriptLevel = 0;
}
// font-kerning: none, enum, inherit, initial, -moz-system-font
SetValue(*aRuleData->ValueForFontKerning(),
aFont->mFont.kerning, aConditions,
- SETVAL_ENUMERATED | SETVAL_SYSTEM_FONT | SETVAL_UNSET_INHERIT,
+ SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT,
aParentFont->mFont.kerning,
defaultVariableFont->kerning,
- 0, 0, 0, systemFont.kerning);
+ Unused, Unused, Unused, systemFont.kerning);
// font-synthesis: none, enum (bit field), inherit, initial, -moz-system-font
SetValue(*aRuleData->ValueForFontSynthesis(),
aFont->mFont.synthesis, aConditions,
- SETVAL_NONE | SETVAL_ENUMERATED | SETVAL_SYSTEM_FONT |
- SETVAL_UNSET_INHERIT,
+ SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT,
aParentFont->mFont.synthesis,
defaultVariableFont->synthesis,
- 0, 0, 0, systemFont.synthesis);
+ Unused, /* none */ 0, Unused, systemFont.synthesis);
// font-variant-alternates: normal, enum (bit field) + functions, inherit,
// initial, -moz-system-font
const nsCSSValue* variantAlternatesValue =
aRuleData->ValueForFontVariantAlternates();
int32_t variantAlternates = 0;
switch (variantAlternatesValue->GetUnit()) {
@@ -3762,61 +3742,57 @@ nsRuleNode::SetFont(nsPresContext* aPres
default:
break;
}
// font-variant-caps: normal, enum, inherit, initial, -moz-system-font
SetValue(*aRuleData->ValueForFontVariantCaps(),
aFont->mFont.variantCaps, aConditions,
- SETVAL_NORMAL | SETVAL_ENUMERATED | SETVAL_SYSTEM_FONT |
- SETVAL_UNSET_INHERIT,
+ SETVAL_ENUMERATED |SETVAL_UNSET_INHERIT,
aParentFont->mFont.variantCaps,
defaultVariableFont->variantCaps,
- 0, 0, 0, systemFont.variantCaps);
+ Unused, Unused, /* normal */ 0, systemFont.variantCaps);
// font-variant-east-asian: normal, enum (bit field), inherit, initial,
// -moz-system-font
SetValue(*aRuleData->ValueForFontVariantEastAsian(),
aFont->mFont.variantEastAsian, aConditions,
- SETVAL_NORMAL | SETVAL_ENUMERATED | SETVAL_SYSTEM_FONT |
- SETVAL_UNSET_INHERIT,
+ SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT,
aParentFont->mFont.variantEastAsian,
defaultVariableFont->variantEastAsian,
- 0, 0, 0, systemFont.variantEastAsian);
+ Unused, Unused, /* normal */ 0, systemFont.variantEastAsian);
// font-variant-ligatures: normal, none, enum (bit field), inherit, initial,
// -moz-system-font
SetValue(*aRuleData->ValueForFontVariantLigatures(),
aFont->mFont.variantLigatures, aConditions,
- SETVAL_NORMAL | SETVAL_NONE | SETVAL_ENUMERATED |
- SETVAL_SYSTEM_FONT | SETVAL_UNSET_INHERIT,
+ SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT,
aParentFont->mFont.variantLigatures,
defaultVariableFont->variantLigatures,
- 0, NS_FONT_VARIANT_LIGATURES_NONE, 0, systemFont.variantLigatures);
+ Unused, NS_FONT_VARIANT_LIGATURES_NONE, /* normal */ 0,
+ systemFont.variantLigatures);
// font-variant-numeric: normal, enum (bit field), inherit, initial,
// -moz-system-font
SetValue(*aRuleData->ValueForFontVariantNumeric(),
aFont->mFont.variantNumeric, aConditions,
- SETVAL_NORMAL | SETVAL_ENUMERATED | SETVAL_SYSTEM_FONT |
- SETVAL_UNSET_INHERIT,
+ SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT,
aParentFont->mFont.variantNumeric,
defaultVariableFont->variantNumeric,
- 0, 0, 0, systemFont.variantNumeric);
+ Unused, Unused, /* normal */ 0, systemFont.variantNumeric);
// font-variant-position: normal, enum, inherit, initial,
// -moz-system-font
SetValue(*aRuleData->ValueForFontVariantPosition(),
aFont->mFont.variantPosition, aConditions,
- SETVAL_NORMAL | SETVAL_ENUMERATED | SETVAL_SYSTEM_FONT |
- SETVAL_UNSET_INHERIT,
+ SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT,
aParentFont->mFont.variantPosition,
defaultVariableFont->variantPosition,
- 0, 0, 0, systemFont.variantPosition);
+ Unused, Unused, /* normal */ 0, systemFont.variantPosition);
// font-feature-settings
const nsCSSValue* featureSettingsValue =
aRuleData->ValueForFontFeatureSettings();
switch (featureSettingsValue->GetUnit()) {
case eCSSUnit_Null:
break;
@@ -4436,17 +4412,17 @@ nsRuleNode::ComputeTextData(void* aStart
const RuleNodeCacheConditions aConditions)
{
COMPUTE_START_INHERITED(Text, text, parentText)
// tab-size: integer, inherit
SetValue(*aRuleData->ValueForTabSize(),
text->mTabSize, conditions,
SETVAL_INTEGER | SETVAL_UNSET_INHERIT, parentText->mTabSize,
- NS_STYLE_TABSIZE_INITIAL, 0, 0, 0, 0);
+ NS_STYLE_TABSIZE_INITIAL);
// letter-spacing: normal, length, inherit
SetCoord(*aRuleData->ValueForLetterSpacing(),
text->mLetterSpacing, parentText->mLetterSpacing,
SETCOORD_LH | SETCOORD_NORMAL | SETCOORD_INITIAL_NORMAL |
SETCOORD_CALC_LENGTH_ONLY | SETCOORD_UNSET_INHERIT,
aContext, mPresContext, conditions);
@@ -4569,17 +4545,17 @@ nsRuleNode::ComputeTextData(void* aStart
}
} else if (eCSSUnit_Inherit == textAlignValue->GetUnit() ||
eCSSUnit_Unset == textAlignValue->GetUnit()) {
text->mTextAlignTrue = parentText->mTextAlignTrue;
}
SetValue(*textAlignValue, text->mTextAlign, conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT,
parentText->mTextAlign,
- NS_STYLE_TEXT_ALIGN_START, 0, 0, 0, 0);
+ NS_STYLE_TEXT_ALIGN_START);
}
// text-align-last: enum, pair(enum), inherit, initial
const nsCSSValue* textAlignLastValue = aRuleData->ValueForTextAlignLast();
text->mTextAlignLastTrue = false;
if (eCSSUnit_Pair == textAlignLastValue->GetUnit()) {
// Two values were specified, one must be 'true'.
text->mTextAlignLastTrue = true;
@@ -4593,41 +4569,41 @@ nsRuleNode::ComputeTextData(void* aStart
} else if (eCSSUnit_Inherit == textAlignLastValue->GetUnit() ||
eCSSUnit_Unset == textAlignLastValue->GetUnit()) {
text->mTextAlignLastTrue = parentText->mTextAlignLastTrue;
}
SetValue(*textAlignLastValue, text->mTextAlignLast,
conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT,
parentText->mTextAlignLast,
- NS_STYLE_TEXT_ALIGN_AUTO, 0, 0, 0, 0);
+ NS_STYLE_TEXT_ALIGN_AUTO);
// text-indent: length, percent, calc, inherit, initial
SetCoord(*aRuleData->ValueForTextIndent(), text->mTextIndent, parentText->mTextIndent,
SETCOORD_LPH | SETCOORD_INITIAL_ZERO | SETCOORD_STORE_CALC |
SETCOORD_UNSET_INHERIT,
aContext, mPresContext, conditions);
// text-transform: enum, inherit, initial
SetValue(*aRuleData->ValueForTextTransform(), text->mTextTransform, conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT,
parentText->mTextTransform,
- NS_STYLE_TEXT_TRANSFORM_NONE, 0, 0, 0, 0);
+ NS_STYLE_TEXT_TRANSFORM_NONE);
// white-space: enum, inherit, initial
SetValue(*aRuleData->ValueForWhiteSpace(), text->mWhiteSpace, conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT,
parentText->mWhiteSpace,
- NS_STYLE_WHITESPACE_NORMAL, 0, 0, 0, 0);
+ NS_STYLE_WHITESPACE_NORMAL);
// word-break: enum, inherit, initial
SetValue(*aRuleData->ValueForWordBreak(), text->mWordBreak, conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT,
parentText->mWordBreak,
- NS_STYLE_WORDBREAK_NORMAL, 0, 0, 0, 0);
+ NS_STYLE_WORDBREAK_NORMAL);
// word-spacing: normal, length, percent, inherit
const nsCSSValue* wordSpacingValue = aRuleData->ValueForWordSpacing();
if (wordSpacingValue->GetUnit() == eCSSUnit_Normal) {
// Do this so that "normal" computes to 0px, as the CSS 2.1 spec requires.
text->mWordSpacing.SetCoordValue(0);
} else {
SetCoord(*aRuleData->ValueForWordSpacing(),
@@ -4636,55 +4612,53 @@ nsRuleNode::ComputeTextData(void* aStart
SETCOORD_STORE_CALC | SETCOORD_UNSET_INHERIT,
aContext, mPresContext, conditions);
}
// overflow-wrap: enum, inherit, initial
SetValue(*aRuleData->ValueForOverflowWrap(), text->mOverflowWrap, conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT,
parentText->mOverflowWrap,
- NS_STYLE_OVERFLOWWRAP_NORMAL, 0, 0, 0, 0);
+ NS_STYLE_OVERFLOWWRAP_NORMAL);
// hyphens: enum, inherit, initial
SetValue(*aRuleData->ValueForHyphens(), text->mHyphens, conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT,
parentText->mHyphens,
- NS_STYLE_HYPHENS_MANUAL, 0, 0, 0, 0);
+ NS_STYLE_HYPHENS_MANUAL);
// ruby-align: enum, inherit, initial
SetValue(*aRuleData->ValueForRubyAlign(),
text->mRubyAlign, conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT,
parentText->mRubyAlign,
- NS_STYLE_RUBY_ALIGN_SPACE_AROUND, 0, 0, 0, 0);
+ NS_STYLE_RUBY_ALIGN_SPACE_AROUND);
// ruby-position: enum, inherit, initial
SetValue(*aRuleData->ValueForRubyPosition(),
text->mRubyPosition, conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT,
parentText->mRubyPosition,
- NS_STYLE_RUBY_POSITION_OVER, 0, 0, 0, 0);
+ NS_STYLE_RUBY_POSITION_OVER);
// text-size-adjust: none, auto, inherit, initial
SetValue(*aRuleData->ValueForTextSizeAdjust(), text->mTextSizeAdjust,
- conditions,
- SETVAL_NONE | SETVAL_AUTO | SETVAL_UNSET_INHERIT,
+ conditions, SETVAL_UNSET_INHERIT,
parentText->mTextSizeAdjust,
- NS_STYLE_TEXT_SIZE_ADJUST_AUTO, // initial value
- NS_STYLE_TEXT_SIZE_ADJUST_AUTO, // auto value
- NS_STYLE_TEXT_SIZE_ADJUST_NONE, // none value
- 0, 0);
+ /* initial */ NS_STYLE_TEXT_SIZE_ADJUST_AUTO,
+ /* auto */ NS_STYLE_TEXT_SIZE_ADJUST_AUTO,
+ /* none */ NS_STYLE_TEXT_SIZE_ADJUST_NONE, Unused, Unused);
// text-combine-upright: enum, inherit, initial
SetValue(*aRuleData->ValueForTextCombineUpright(),
text->mTextCombineUpright,
conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT,
parentText->mTextCombineUpright,
- NS_STYLE_TEXT_COMBINE_UPRIGHT_NONE, 0, 0, 0, 0);
+ NS_STYLE_TEXT_COMBINE_UPRIGHT_NONE);
// text-emphasis-color: color, string, inherit, initial
const nsCSSValue*
textEmphasisColorValue = aRuleData->ValueForTextEmphasisColor();
if (textEmphasisColorValue->GetUnit() == eCSSUnit_Null) {
// We don't want to change anything in this case.
} else if (textEmphasisColorValue->GetUnit() == eCSSUnit_Inherit ||
textEmphasisColorValue->GetUnit() == eCSSUnit_Unset) {
@@ -4705,17 +4679,17 @@ nsRuleNode::ComputeTextData(void* aStart
// text-emphasis-position: enum, inherit, initial
SetValue(*aRuleData->ValueForTextEmphasisPosition(),
text->mTextEmphasisPosition,
conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT,
parentText->mTextEmphasisPosition,
NS_STYLE_TEXT_EMPHASIS_POSITION_OVER |
- NS_STYLE_TEXT_EMPHASIS_POSITION_RIGHT, 0, 0, 0, 0);
+ NS_STYLE_TEXT_EMPHASIS_POSITION_RIGHT);
// text-emphasis-style: string, enum, inherit, initial
const nsCSSValue* textEmphasisStyleValue =
aRuleData->ValueForTextEmphasisStyle();
switch (textEmphasisStyleValue->GetUnit()) {
case eCSSUnit_Null:
break;
case eCSSUnit_Initial:
@@ -4767,17 +4741,17 @@ nsRuleNode::ComputeTextData(void* aStart
MOZ_ASSERT_UNREACHABLE("Unknown value unit type");
}
// text-rendering: enum, inherit, initial
SetValue(*aRuleData->ValueForTextRendering(),
text->mTextRendering, conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT,
parentText->mTextRendering,
- NS_STYLE_TEXT_RENDERING_AUTO, 0, 0, 0, 0);
+ NS_STYLE_TEXT_RENDERING_AUTO);
// -webkit-text-fill-color: color, string, inherit, initial
const nsCSSValue*
webkitTextFillColorValue = aRuleData->ValueForWebkitTextFillColor();
if (webkitTextFillColorValue->GetUnit() == eCSSUnit_Null) {
// We don't want to change anything in this case.
} else if (webkitTextFillColorValue->GetUnit() == eCSSUnit_Inherit ||
webkitTextFillColorValue->GetUnit() == eCSSUnit_Unset) {
@@ -4837,17 +4811,17 @@ nsRuleNode::ComputeTextData(void* aStart
}
// -moz-control-character-visibility: enum, inherit, initial
SetValue(*aRuleData->ValueForControlCharacterVisibility(),
text->mControlCharacterVisibility,
conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT,
parentText->mControlCharacterVisibility,
- nsCSSParser::ControlCharVisibilityDefault(), 0, 0, 0, 0);
+ nsCSSParser::ControlCharVisibilityDefault());
COMPUTE_END_INHERITED(Text, text)
}
const void*
nsRuleNode::ComputeTextResetData(void* aStartStruct,
const nsRuleData* aRuleData,
nsStyleContext* aContext,
@@ -4939,17 +4913,17 @@ nsRuleNode::ComputeTextResetData(void* a
} else if (eCSSUnit_Inherit == textOverflowValue->GetUnit()) {
conditions.SetUncacheable();
text->mTextOverflow = parentText->mTextOverflow;
} else if (eCSSUnit_Enumerated == textOverflowValue->GetUnit()) {
// A single enumerated value.
SetValue(*textOverflowValue, text->mTextOverflow.mRight.mType,
conditions,
SETVAL_ENUMERATED, parentText->mTextOverflow.mRight.mType,
- NS_STYLE_TEXT_OVERFLOW_CLIP, 0, 0, 0, 0);
+ NS_STYLE_TEXT_OVERFLOW_CLIP);
text->mTextOverflow.mRight.mString.Truncate();
text->mTextOverflow.mLeft.mType = NS_STYLE_TEXT_OVERFLOW_CLIP;
text->mTextOverflow.mLeft.mString.Truncate();
text->mTextOverflow.mLogicalDirections = true;
} else if (eCSSUnit_String == textOverflowValue->GetUnit()) {
// A single string value.
text->mTextOverflow.mRight.mType = NS_STYLE_TEXT_OVERFLOW_STRING;
textOverflowValue->GetStringValue(text->mTextOverflow.mRight.mString);
@@ -4962,41 +4936,41 @@ nsRuleNode::ComputeTextResetData(void* a
const nsCSSValuePair& textOverflowValuePair =
textOverflowValue->GetPairValue();
const nsCSSValue *textOverflowLeftValue = &textOverflowValuePair.mXValue;
if (eCSSUnit_Enumerated == textOverflowLeftValue->GetUnit()) {
SetValue(*textOverflowLeftValue, text->mTextOverflow.mLeft.mType,
conditions,
SETVAL_ENUMERATED, parentText->mTextOverflow.mLeft.mType,
- NS_STYLE_TEXT_OVERFLOW_CLIP, 0, 0, 0, 0);
+ NS_STYLE_TEXT_OVERFLOW_CLIP);
text->mTextOverflow.mLeft.mString.Truncate();
} else if (eCSSUnit_String == textOverflowLeftValue->GetUnit()) {
textOverflowLeftValue->GetStringValue(text->mTextOverflow.mLeft.mString);
text->mTextOverflow.mLeft.mType = NS_STYLE_TEXT_OVERFLOW_STRING;
}
const nsCSSValue *textOverflowRightValue = &textOverflowValuePair.mYValue;
if (eCSSUnit_Enumerated == textOverflowRightValue->GetUnit()) {
SetValue(*textOverflowRightValue, text->mTextOverflow.mRight.mType,
conditions,
SETVAL_ENUMERATED, parentText->mTextOverflow.mRight.mType,
- NS_STYLE_TEXT_OVERFLOW_CLIP, 0, 0, 0, 0);
+ NS_STYLE_TEXT_OVERFLOW_CLIP);
text->mTextOverflow.mRight.mString.Truncate();
} else if (eCSSUnit_String == textOverflowRightValue->GetUnit()) {
textOverflowRightValue->GetStringValue(text->mTextOverflow.mRight.mString);
text->mTextOverflow.mRight.mType = NS_STYLE_TEXT_OVERFLOW_STRING;
}
}
// unicode-bidi: enum, inherit, initial
SetValue(*aRuleData->ValueForUnicodeBidi(), text->mUnicodeBidi, conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL,
parentText->mUnicodeBidi,
- NS_STYLE_UNICODE_BIDI_NORMAL, 0, 0, 0, 0);
+ NS_STYLE_UNICODE_BIDI_NORMAL);
COMPUTE_END_RESET(TextReset, text)
}
const void*
nsRuleNode::ComputeUserInterfaceData(void* aStartStruct,
const nsRuleData* aRuleData,
nsStyleContext* aContext,
@@ -5066,39 +5040,38 @@ nsRuleNode::ComputeUserInterfaceData(voi
}
}
// user-input: enum, inherit, initial
SetValue(*aRuleData->ValueForUserInput(),
ui->mUserInput, conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT,
parentUI->mUserInput,
- NS_STYLE_USER_INPUT_AUTO, 0, 0, 0, 0);
+ NS_STYLE_USER_INPUT_AUTO);
// user-modify: enum, inherit, initial
SetValue(*aRuleData->ValueForUserModify(),
ui->mUserModify, conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT,
parentUI->mUserModify,
- NS_STYLE_USER_MODIFY_READ_ONLY,
- 0, 0, 0, 0);
+ NS_STYLE_USER_MODIFY_READ_ONLY);
// user-focus: enum, inherit, initial
SetValue(*aRuleData->ValueForUserFocus(),
ui->mUserFocus, conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT,
parentUI->mUserFocus,
- NS_STYLE_USER_FOCUS_NONE, 0, 0, 0, 0);
+ NS_STYLE_USER_FOCUS_NONE);
// pointer-events: enum, inherit, initial
SetValue(*aRuleData->ValueForPointerEvents(), ui->mPointerEvents,
conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT,
parentUI->mPointerEvents,
- NS_STYLE_POINTER_EVENTS_AUTO, 0, 0, 0, 0);
+ NS_STYLE_POINTER_EVENTS_AUTO);
COMPUTE_END_INHERITED(UserInterface, ui)
}
const void*
nsRuleNode::ComputeUIResetData(void* aStartStruct,
const nsRuleData* aRuleData,
nsStyleContext* aContext,
@@ -5108,46 +5081,45 @@ nsRuleNode::ComputeUIResetData(void* aSt
{
COMPUTE_START_RESET(UIReset, ui, parentUI)
// user-select: enum, inherit, initial
SetValue(*aRuleData->ValueForUserSelect(),
ui->mUserSelect, conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL,
parentUI->mUserSelect,
- NS_STYLE_USER_SELECT_AUTO, 0, 0, 0, 0);
+ NS_STYLE_USER_SELECT_AUTO);
// ime-mode: enum, inherit, initial
SetValue(*aRuleData->ValueForImeMode(),
ui->mIMEMode, conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL,
parentUI->mIMEMode,
- NS_STYLE_IME_MODE_AUTO, 0, 0, 0, 0);
+ NS_STYLE_IME_MODE_AUTO);
// force-broken-image-icons: integer, inherit, initial
SetValue(*aRuleData->ValueForForceBrokenImageIcon(),
ui->mForceBrokenImageIcon,
conditions,
SETVAL_INTEGER | SETVAL_UNSET_INITIAL,
- parentUI->mForceBrokenImageIcon,
- 0, 0, 0, 0, 0);
+ parentUI->mForceBrokenImageIcon, 0);
// -moz-window-dragging: enum, inherit, initial
SetValue(*aRuleData->ValueForWindowDragging(),
ui->mWindowDragging, conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL,
parentUI->mWindowDragging,
- NS_STYLE_WINDOW_DRAGGING_DEFAULT, 0, 0, 0, 0);
+ NS_STYLE_WINDOW_DRAGGING_DEFAULT);
// -moz-window-shadow: enum, inherit, initial
SetValue(*aRuleData->ValueForWindowShadow(),
ui->mWindowShadow, conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL,
parentUI->mWindowShadow,
- NS_STYLE_WINDOW_SHADOW_DEFAULT, 0, 0, 0, 0);
+ NS_STYLE_WINDOW_SHADOW_DEFAULT);
COMPUTE_END_RESET(UIReset, ui)
}
// Information about each transition or animation property that is
// constant.
struct TransitionPropInfo {
nsCSSProperty property;
@@ -5765,44 +5737,42 @@ nsRuleNode::ComputeDisplayData(void* aSt
}
}
}
// display: enum, inherit, initial
SetValue(*aRuleData->ValueForDisplay(), display->mDisplay, conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL,
parentDisplay->mDisplay,
- NS_STYLE_DISPLAY_INLINE, 0, 0, 0, 0);
+ NS_STYLE_DISPLAY_INLINE);
// contain: none, enum, inherit, initial
SetValue(*aRuleData->ValueForContain(), display->mContain, conditions,
- SETVAL_ENUMERATED | SETVAL_NONE | SETVAL_UNSET_INITIAL,
+ SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL,
parentDisplay->mContain,
- NS_STYLE_CONTAIN_NONE, 0, NS_STYLE_CONTAIN_NONE, 0, 0);
+ NS_STYLE_CONTAIN_NONE, Unused,
+ NS_STYLE_CONTAIN_NONE, Unused, Unused);
// scroll-behavior: enum, inherit, initial
SetValue(*aRuleData->ValueForScrollBehavior(), display->mScrollBehavior,
conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL,
- parentDisplay->mScrollBehavior, NS_STYLE_SCROLL_BEHAVIOR_AUTO,
- 0, 0, 0, 0);
+ parentDisplay->mScrollBehavior, NS_STYLE_SCROLL_BEHAVIOR_AUTO);
// scroll-snap-type-x: none, enum, inherit, initial
SetValue(*aRuleData->ValueForScrollSnapTypeX(), display->mScrollSnapTypeX,
conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL,
- parentDisplay->mScrollSnapTypeX, NS_STYLE_SCROLL_SNAP_TYPE_NONE,
- 0, 0, 0, 0);
+ parentDisplay->mScrollSnapTypeX, NS_STYLE_SCROLL_SNAP_TYPE_NONE);
// scroll-snap-type-y: none, enum, inherit, initial
SetValue(*aRuleData->ValueForScrollSnapTypeY(), display->mScrollSnapTypeY,
conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL,
- parentDisplay->mScrollSnapTypeY, NS_STYLE_SCROLL_SNAP_TYPE_NONE,
- 0, 0, 0, 0);
+ parentDisplay->mScrollSnapTypeY, NS_STYLE_SCROLL_SNAP_TYPE_NONE);
// scroll-snap-points-x: none, inherit, initial
const nsCSSValue& scrollSnapPointsX = *aRuleData->ValueForScrollSnapPointsX();
switch (scrollSnapPointsX.GetUnit()) {
case eCSSUnit_Null:
break;
case eCSSUnit_Initial:
case eCSSUnit_Unset:
@@ -5923,37 +5893,35 @@ nsRuleNode::ComputeDisplayData(void* aSt
default:
NS_NOTREACHED("unexpected unit");
}
// isolation: enum, inherit, initial
SetValue(*aRuleData->ValueForIsolation(), display->mIsolation,
conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL,
- parentDisplay->mIsolation, NS_STYLE_ISOLATION_AUTO,
- 0, 0, 0, 0);
+ parentDisplay->mIsolation, NS_STYLE_ISOLATION_AUTO);
// -moz-top-layer: enum, inherit, initial
SetValue(*aRuleData->ValueForTopLayer(), display->mTopLayer,
conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL,
- parentDisplay->mTopLayer, NS_STYLE_TOP_LAYER_NONE,
- 0, 0, 0, 0);
+ parentDisplay->mTopLayer, NS_STYLE_TOP_LAYER_NONE);
// Backup original display value for calculation of a hypothetical
// box (CSS2 10.6.4/10.6.5), in addition to getting our style data right later.
// See nsHTMLReflowState::CalculateHypotheticalBox
display->mOriginalDisplay = display->mDisplay;
// appearance: enum, inherit, initial
SetValue(*aRuleData->ValueForAppearance(),
display->mAppearance, conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL,
parentDisplay->mAppearance,
- NS_THEME_NONE, 0, 0, 0, 0);
+ NS_THEME_NONE);
// binding: url, none, inherit
const nsCSSValue* bindingValue = aRuleData->ValueForBinding();
if (eCSSUnit_URL == bindingValue->GetUnit()) {
mozilla::css::URLValue* url = bindingValue->GetURLStructValue();
NS_ASSERTION(url, "What's going on here?");
if (MOZ_LIKELY(url->GetURI())) {
@@ -5971,33 +5939,33 @@ nsRuleNode::ComputeDisplayData(void* aSt
conditions.SetUncacheable();
display->mBinding = parentDisplay->mBinding;
}
// position: enum, inherit, initial
SetValue(*aRuleData->ValueForPosition(), display->mPosition, conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL,
parentDisplay->mPosition,
- NS_STYLE_POSITION_STATIC, 0, 0, 0, 0);
+ NS_STYLE_POSITION_STATIC);
// If an element is put in the top layer, while it is not absolutely
// positioned, the position value should be computed to 'absolute' per
// the Fullscreen API spec.
if (display->mTopLayer != NS_STYLE_TOP_LAYER_NONE &&
!display->IsAbsolutelyPositionedStyle()) {
display->mPosition = NS_STYLE_POSITION_ABSOLUTE;
// We cannot cache this struct because otherwise it may be used as
// an aStartStruct for some other elements.
conditions.SetUncacheable();
}
// clear: enum, inherit, initial
SetValue(*aRuleData->ValueForClear(), display->mBreakType, conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL,
parentDisplay->mBreakType,
- NS_STYLE_CLEAR_NONE, 0, 0, 0, 0);
+ NS_STYLE_CLEAR_NONE);
// temp fix for bug 24000
// Map 'auto' and 'avoid' to false, and 'always', 'left', and
// 'right' to true.
// "A conforming user agent may interpret the values 'left' and
// 'right' as 'always'." - CSS2.1, section 13.3.1
const nsCSSValue* breakBeforeValue = aRuleData->ValueForPageBreakBefore();
if (eCSSUnit_Enumerated == breakBeforeValue->GetUnit()) {
@@ -6030,50 +5998,49 @@ nsRuleNode::ComputeDisplayData(void* aSt
}
// end temp fix
// page-break-inside: enum, inherit, initial
SetValue(*aRuleData->ValueForPageBreakInside(),
display->mBreakInside, conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL,
parentDisplay->mBreakInside,
- NS_STYLE_PAGE_BREAK_AUTO, 0, 0, 0, 0);
+ NS_STYLE_PAGE_BREAK_AUTO);
// touch-action: none, auto, enum, inherit, initial
SetValue(*aRuleData->ValueForTouchAction(), display->mTouchAction,
conditions,
- SETVAL_ENUMERATED | SETVAL_AUTO | SETVAL_NONE |
- SETVAL_UNSET_INITIAL,
+ SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL,
parentDisplay->mTouchAction,
- NS_STYLE_TOUCH_ACTION_AUTO,
- NS_STYLE_TOUCH_ACTION_AUTO,
- NS_STYLE_TOUCH_ACTION_NONE, 0, 0);
+ /* initial */ NS_STYLE_TOUCH_ACTION_AUTO,
+ /* auto */ NS_STYLE_TOUCH_ACTION_AUTO,
+ /* none */ NS_STYLE_TOUCH_ACTION_NONE, Unused, Unused);
// float: enum, inherit, initial
SetValue(*aRuleData->ValueForFloat(),
display->mFloats, conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL,
parentDisplay->mFloats,
- NS_STYLE_FLOAT_NONE, 0, 0, 0, 0);
+ NS_STYLE_FLOAT_NONE);
// Save mFloats in mOriginalFloats in case we need it later
display->mOriginalFloats = display->mFloats;
// overflow-x: enum, inherit, initial
SetValue(*aRuleData->ValueForOverflowX(),
display->mOverflowX, conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL,
parentDisplay->mOverflowX,
- NS_STYLE_OVERFLOW_VISIBLE, 0, 0, 0, 0);
+ NS_STYLE_OVERFLOW_VISIBLE);
// overflow-y: enum, inherit, initial
SetValue(*aRuleData->ValueForOverflowY(),
display->mOverflowY, conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL,
parentDisplay->mOverflowY,
- NS_STYLE_OVERFLOW_VISIBLE, 0, 0, 0, 0);
+ NS_STYLE_OVERFLOW_VISIBLE);
// CSS3 overflow-x and overflow-y require some fixup as well in some
// cases. NS_STYLE_OVERFLOW_VISIBLE and NS_STYLE_OVERFLOW_CLIP are
// meaningful only when used in both dimensions.
if (display->mOverflowX != display->mOverflowY &&
(display->mOverflowX == NS_STYLE_OVERFLOW_VISIBLE ||
display->mOverflowX == NS_STYLE_OVERFLOW_CLIP ||
display->mOverflowY == NS_STYLE_OVERFLOW_VISIBLE ||
@@ -6111,22 +6078,22 @@ nsRuleNode::ComputeDisplayData(void* aSt
conditions.SetUncacheable();
}
}
SetValue(*aRuleData->ValueForOverflowClipBox(), display->mOverflowClipBox,
conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL,
parentDisplay->mOverflowClipBox,
- NS_STYLE_OVERFLOW_CLIP_BOX_PADDING_BOX, 0, 0, 0, 0);
+ NS_STYLE_OVERFLOW_CLIP_BOX_PADDING_BOX);
SetValue(*aRuleData->ValueForResize(), display->mResize, conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL,
parentDisplay->mResize,
- NS_STYLE_RESIZE_NONE, 0, 0, 0, 0);
+ NS_STYLE_RESIZE_NONE);
if (display->mDisplay != NS_STYLE_DISPLAY_NONE) {
// CSS2 9.7 specifies display type corrections dealing with 'float'
// and 'position'. Since generated content can't be floated or
// positioned, we can deal with it here.
nsIAtom* pseudo = aContext->GetPseudo();
if (pseudo && display->mDisplay == NS_STYLE_DISPLAY_CONTENTS) {
@@ -6394,38 +6361,38 @@ nsRuleNode::ComputeDisplayData(void* aSt
SETCOORD_LAH | SETCOORD_INITIAL_NONE | SETCOORD_NONE |
SETCOORD_UNSET_INITIAL,
aContext, mPresContext, conditions);
SetValue(*aRuleData->ValueForBackfaceVisibility(),
display->mBackfaceVisibility, conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL,
parentDisplay->mBackfaceVisibility,
- NS_STYLE_BACKFACE_VISIBILITY_VISIBLE, 0, 0, 0, 0);
+ NS_STYLE_BACKFACE_VISIBILITY_VISIBLE);
// transform-style: enum, inherit, initial
SetValue(*aRuleData->ValueForTransformStyle(),
display->mTransformStyle, conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL,
parentDisplay->mTransformStyle,
- NS_STYLE_TRANSFORM_STYLE_FLAT, 0, 0, 0, 0);
+ NS_STYLE_TRANSFORM_STYLE_FLAT);
// transform-box: enum, inherit, initial
SetValue(*aRuleData->ValueForTransformBox(),
display->mTransformBox, conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL,
parentDisplay->mTransformBox,
- NS_STYLE_TRANSFORM_BOX_BORDER_BOX, 0, 0, 0, 0);
+ NS_STYLE_TRANSFORM_BOX_BORDER_BOX);
// orient: enum, inherit, initial
SetValue(*aRuleData->ValueForOrient(),
display->mOrient, conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL,
parentDisplay->mOrient,
- NS_STYLE_ORIENT_INLINE, 0, 0, 0, 0);
+ NS_STYLE_ORIENT_INLINE);
COMPUTE_END_RESET(Display, display)
}
const void*
nsRuleNode::ComputeVisibilityData(void* aStartStruct,
const nsRuleData* aRuleData,
nsStyleContext* aContext,
@@ -6441,46 +6408,45 @@ nsRuleNode::ComputeVisibilityData(void*
// direction: enum, inherit, initial
SetValue(*aRuleData->ValueForDirection(), visibility->mDirection,
conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT,
parentVisibility->mDirection,
(GET_BIDI_OPTION_DIRECTION(mPresContext->GetBidi())
== IBMBIDI_TEXTDIRECTION_RTL)
- ? NS_STYLE_DIRECTION_RTL : NS_STYLE_DIRECTION_LTR,
- 0, 0, 0, 0);
+ ? NS_STYLE_DIRECTION_RTL : NS_STYLE_DIRECTION_LTR);
// visibility: enum, inherit, initial
SetValue(*aRuleData->ValueForVisibility(), visibility->mVisible,
conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT,
parentVisibility->mVisible,
- NS_STYLE_VISIBILITY_VISIBLE, 0, 0, 0, 0);
+ NS_STYLE_VISIBILITY_VISIBLE);
// image-rendering: enum, inherit
SetValue(*aRuleData->ValueForImageRendering(),
visibility->mImageRendering, conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT,
parentVisibility->mImageRendering,
- NS_STYLE_IMAGE_RENDERING_AUTO, 0, 0, 0, 0);
+ NS_STYLE_IMAGE_RENDERING_AUTO);
// writing-mode: enum, inherit, initial
SetValue(*aRuleData->ValueForWritingMode(), visibility->mWritingMode,
conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT,
parentVisibility->mWritingMode,
- NS_STYLE_WRITING_MODE_HORIZONTAL_TB, 0, 0, 0, 0);
+ NS_STYLE_WRITING_MODE_HORIZONTAL_TB);
// text-orientation: enum, inherit, initial
SetValue(*aRuleData->ValueForTextOrientation(), visibility->mTextOrientation,
conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT,
parentVisibility->mTextOrientation,
- NS_STYLE_TEXT_ORIENTATION_MIXED, 0, 0, 0, 0);
+ NS_STYLE_TEXT_ORIENTATION_MIXED);
// image-orientation: enum, inherit, initial
const nsCSSValue* orientation = aRuleData->ValueForImageOrientation();
if (orientation->GetUnit() == eCSSUnit_Inherit ||
orientation->GetUnit() == eCSSUnit_Unset) {
conditions.SetUncacheable();
visibility->mImageOrientation = parentVisibility->mImageOrientation;
} else if (orientation->GetUnit() == eCSSUnit_Initial) {
@@ -6514,17 +6480,17 @@ nsRuleNode::ComputeVisibilityData(void*
} else {
MOZ_ASSERT(orientation->GetUnit() == eCSSUnit_Null, "Should be null unit");
}
SetValue(*aRuleData->ValueForColorAdjust(), visibility->mColorAdjust,
conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT,
parentVisibility->mColorAdjust,
- NS_STYLE_COLOR_ADJUST_ECONOMY, 0, 0, 0, 0);
+ NS_STYLE_COLOR_ADJUST_ECONOMY);
COMPUTE_END_INHERITED(Visibility, visibility)
}
const void*
nsRuleNode::ComputeColorData(void* aStartStruct,
const nsRuleData* aRuleData,
nsStyleContext* aContext,
@@ -6564,17 +6530,17 @@ template <>
struct BackgroundItemComputer<nsCSSValueList, uint8_t>
{
static void ComputeValue(nsStyleContext* aStyleContext,
const nsCSSValueList* aSpecifiedValue,
uint8_t& aComputedValue,
RuleNodeCacheConditions& aConditions)
{
SetValue(aSpecifiedValue->mValue, aComputedValue, aConditions,
- SETVAL_ENUMERATED, uint8_t(0), 0, 0, 0, 0, 0);
+ SETVAL_ENUMERATED, uint8_t(0), 0);
}
};
template <>
struct BackgroundItemComputer<nsCSSValuePairList, nsStyleImageLayers::Repeat>
{
static void ComputeValue(nsStyleContext* aStyleContext,
const nsCSSValuePairList* aSpecifiedValue,
@@ -7391,17 +7357,17 @@ nsRuleNode::ComputeBorderData(void* aSta
{
COMPUTE_START_RESET(Border, border, parentBorder)
// box-decoration-break: enum, inherit, initial
SetValue(*aRuleData->ValueForBoxDecorationBreak(),
border->mBoxDecorationBreak, conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL,
parentBorder->mBoxDecorationBreak,
- NS_STYLE_BOX_DECORATION_BREAK_SLICE, 0, 0, 0, 0);
+ NS_STYLE_BOX_DECORATION_BREAK_SLICE);
// border-width, border-*-width: length, enum, inherit
nsStyleCoord coord;
{
const nsCSSProperty* subprops =
nsCSSProps::SubpropertyEntryFor(eCSSProperty_border_width);
NS_FOR_CSS_SIDES(side) {
const nsCSSValue& value = *aRuleData->ValueFor(subprops[side]);
@@ -7598,17 +7564,17 @@ nsRuleNode::ComputeBorderData(void* aSta
}
}
// float-edge: enum, inherit, initial
SetValue(*aRuleData->ValueForFloatEdge(),
border->mFloatEdge, conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL,
parentBorder->mFloatEdge,
- NS_STYLE_FLOAT_EDGE_CONTENT_BOX, 0, 0, 0, 0);
+ NS_STYLE_FLOAT_EDGE_CONTENT_BOX);
// border-image-source
const nsCSSValue* borderImageSource = aRuleData->ValueForBorderImageSource();
if (borderImageSource->GetUnit() == eCSSUnit_Inherit) {
conditions.SetUncacheable();
border->mBorderImageSource = parentBorder->mBorderImageSource;
} else {
SetStyleImage(aContext,
@@ -7623,17 +7589,17 @@ nsRuleNode::ComputeBorderData(void* aSta
borderImageSliceValue, borderImageSliceFill);
// border-image-slice: fill
SetValue(borderImageSliceFill,
border->mBorderImageFill,
conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL,
parentBorder->mBorderImageFill,
- NS_STYLE_BORDER_IMAGE_SLICE_NOFILL, 0, 0, 0, 0);
+ NS_STYLE_BORDER_IMAGE_SLICE_NOFILL);
nsCSSRect borderImageSlice;
SetBorderImageRect(borderImageSliceValue, borderImageSlice);
nsCSSRect borderImageWidth;
SetBorderImageRect(*aRuleData->ValueForBorderImageWidth(),
borderImageWidth);
@@ -7678,24 +7644,24 @@ nsRuleNode::ComputeBorderData(void* aSta
SetBorderImagePair(*aRuleData->ValueForBorderImageRepeat(),
borderImageRepeat);
SetValue(borderImageRepeat.mXValue,
border->mBorderImageRepeatH,
conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL,
parentBorder->mBorderImageRepeatH,
- NS_STYLE_BORDER_IMAGE_REPEAT_STRETCH, 0, 0, 0, 0);
+ NS_STYLE_BORDER_IMAGE_REPEAT_STRETCH);
SetValue(borderImageRepeat.mYValue,
border->mBorderImageRepeatV,
conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL,
parentBorder->mBorderImageRepeatV,
- NS_STYLE_BORDER_IMAGE_REPEAT_STRETCH, 0, 0, 0, 0);
+ NS_STYLE_BORDER_IMAGE_REPEAT_STRETCH);
border->TrackImage(aContext->PresContext());
COMPUTE_END_RESET(Border, border)
}
const void*
nsRuleNode::ComputePaddingData(void* aStartStruct,
@@ -7965,17 +7931,17 @@ nsRuleNode::ComputeListData(void* aStart
parentList->GetListStyleImage())
}
// list-style-position: enum, inherit, initial
SetValue(*aRuleData->ValueForListStylePosition(),
list->mListStylePosition, conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT,
parentList->mListStylePosition,
- NS_STYLE_LIST_STYLE_POSITION_OUTSIDE, 0, 0, 0, 0);
+ NS_STYLE_LIST_STYLE_POSITION_OUTSIDE);
// image region property: length, auto, inherit
const nsCSSValue* imageRegionValue = aRuleData->ValueForImageRegion();
switch (imageRegionValue->GetUnit()) {
case eCSSUnit_Inherit:
case eCSSUnit_Unset:
conditions.SetUncacheable();
list->mImageRegion = parentList->mImageRegion;
@@ -8442,24 +8408,24 @@ nsRuleNode::ComputePositionData(void* aS
parentPos->mBoxSizing,
StyleBoxSizing::Content);
// align-content: enum, inherit, initial
SetValue(*aRuleData->ValueForAlignContent(),
pos->mAlignContent, conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL,
parentPos->mAlignContent,
- NS_STYLE_ALIGN_NORMAL, 0, 0, 0, 0);
+ NS_STYLE_ALIGN_NORMAL);
// align-items: enum, inherit, initial
SetValue(*aRuleData->ValueForAlignItems(),
pos->mAlignItems, conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL,
parentPos->mAlignItems,
- NS_STYLE_ALIGN_NORMAL, 0, 0, 0, 0);
+ NS_STYLE_ALIGN_NORMAL);
// align-self: enum, inherit, initial
const auto& alignSelfValue = *aRuleData->ValueForAlignSelf();
if (MOZ_UNLIKELY(alignSelfValue.GetUnit() == eCSSUnit_Inherit)) {
if (MOZ_LIKELY(parentContext)) {
nsStyleContext* grandparentContext = parentContext->GetParent();
if (MOZ_LIKELY(grandparentContext)) {
parentContext->AddStyleBit(NS_STYLE_CHILD_USES_GRANDANCESTOR_STYLE);
@@ -8469,42 +8435,42 @@ nsRuleNode::ComputePositionData(void* aS
pos->mAlignSelf = NS_STYLE_ALIGN_NORMAL;
}
conditions.SetUncacheable();
} else {
SetValue(alignSelfValue,
pos->mAlignSelf, conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL,
parentPos->mAlignSelf, // unused, we handle 'inherit' above
- NS_STYLE_ALIGN_AUTO, 0, 0, 0, 0);
+ NS_STYLE_ALIGN_AUTO);
}
// justify-content: enum, inherit, initial
SetValue(*aRuleData->ValueForJustifyContent(),
pos->mJustifyContent, conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL,
parentPos->mJustifyContent,
- NS_STYLE_JUSTIFY_NORMAL, 0, 0, 0, 0);
+ NS_STYLE_JUSTIFY_NORMAL);
// justify-items: enum, inherit, initial
const auto& justifyItemsValue = *aRuleData->ValueForJustifyItems();
if (MOZ_UNLIKELY(justifyItemsValue.GetUnit() == eCSSUnit_Inherit)) {
if (MOZ_LIKELY(parentContext)) {
pos->mJustifyItems =
parentPos->ComputedJustifyItems(parentContext->GetParent());
} else {
pos->mJustifyItems = NS_STYLE_JUSTIFY_NORMAL;
}
conditions.SetUncacheable();
} else {
SetValue(justifyItemsValue,
pos->mJustifyItems, conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL,
parentPos->mJustifyItems, // unused, we handle 'inherit' above
- NS_STYLE_JUSTIFY_AUTO, 0, 0, 0, 0);
+ NS_STYLE_JUSTIFY_AUTO);
}
// justify-self: enum, inherit, initial
const auto& justifySelfValue = *aRuleData->ValueForJustifySelf();
if (MOZ_UNLIKELY(justifySelfValue.GetUnit() == eCSSUnit_Inherit)) {
if (MOZ_LIKELY(parentContext)) {
nsStyleContext* grandparentContext = parentContext->GetParent();
if (MOZ_LIKELY(grandparentContext)) {
@@ -8515,32 +8481,32 @@ nsRuleNode::ComputePositionData(void* aS
pos->mJustifySelf = NS_STYLE_JUSTIFY_NORMAL;
}
conditions.SetUncacheable();
} else {
SetValue(justifySelfValue,
pos->mJustifySelf, conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL,
parentPos->mJustifySelf, // not used, we handle 'inherit' above
- NS_STYLE_JUSTIFY_AUTO, 0, 0, 0, 0);
+ NS_STYLE_JUSTIFY_AUTO);
}
// flex-basis: auto, length, percent, enum, calc, inherit, initial
// (Note: The flags here should match those used for 'width' property above.)
SetCoord(*aRuleData->ValueForFlexBasis(), pos->mFlexBasis, parentPos->mFlexBasis,
SETCOORD_LPAEH | SETCOORD_INITIAL_AUTO | SETCOORD_STORE_CALC |
SETCOORD_UNSET_INITIAL,
aContext, mPresContext, conditions);
// flex-direction: enum, inherit, initial
SetValue(*aRuleData->ValueForFlexDirection(),
pos->mFlexDirection, conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL,
parentPos->mFlexDirection,
- NS_STYLE_FLEX_DIRECTION_ROW, 0, 0, 0, 0);
+ NS_STYLE_FLEX_DIRECTION_ROW);
// flex-grow: float, inherit, initial
SetFactor(*aRuleData->ValueForFlexGrow(),
pos->mFlexGrow, conditions,
parentPos->mFlexGrow, 0.0f,
SETFCT_UNSET_INITIAL);
// flex-shrink: float, inherit, initial
@@ -8549,31 +8515,31 @@ nsRuleNode::ComputePositionData(void* aS
parentPos->mFlexShrink, 1.0f,
SETFCT_UNSET_INITIAL);
// flex-wrap: enum, inherit, initial
SetValue(*aRuleData->ValueForFlexWrap(),
pos->mFlexWrap, conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL,
parentPos->mFlexWrap,
- NS_STYLE_FLEX_WRAP_NOWRAP, 0, 0, 0, 0);
+ NS_STYLE_FLEX_WRAP_NOWRAP);
// order: integer, inherit, initial
SetValue(*aRuleData->ValueForOrder(),
pos->mOrder, conditions,
SETVAL_INTEGER | SETVAL_UNSET_INITIAL,
parentPos->mOrder,
- NS_STYLE_ORDER_INITIAL, 0, 0, 0, 0);
+ NS_STYLE_ORDER_INITIAL);
// object-fit: enum, inherit, initial
SetValue(*aRuleData->ValueForObjectFit(),
pos->mObjectFit, conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL,
parentPos->mObjectFit,
- NS_STYLE_OBJECT_FIT_FILL, 0, 0, 0, 0);
+ NS_STYLE_OBJECT_FIT_FILL);
// object-position
const nsCSSValue& objectPosition = *aRuleData->ValueForObjectPosition();
switch (objectPosition.GetUnit()) {
case eCSSUnit_Null:
break;
case eCSSUnit_Inherit:
conditions.SetUncacheable();
@@ -8710,17 +8676,17 @@ nsRuleNode::ComputeTableData(void* aStar
{
COMPUTE_START_RESET(Table, table, parentTable)
// table-layout: enum, inherit, initial
SetValue(*aRuleData->ValueForTableLayout(),
table->mLayoutStrategy, conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL,
parentTable->mLayoutStrategy,
- NS_STYLE_TABLE_LAYOUT_AUTO, 0, 0, 0, 0);
+ NS_STYLE_TABLE_LAYOUT_AUTO);
// span: pixels (not a real CSS prop)
const nsCSSValue* spanValue = aRuleData->ValueForSpan();
if (eCSSUnit_Enumerated == spanValue->GetUnit() ||
eCSSUnit_Integer == spanValue->GetUnit())
table->mSpan = spanValue->GetIntValue();
COMPUTE_END_RESET(Table, table)
@@ -8736,17 +8702,17 @@ nsRuleNode::ComputeTableBorderData(void*
{
COMPUTE_START_INHERITED(TableBorder, table, parentTable)
// border-collapse: enum, inherit, initial
SetValue(*aRuleData->ValueForBorderCollapse(), table->mBorderCollapse,
conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT,
parentTable->mBorderCollapse,
- NS_STYLE_BORDER_SEPARATE, 0, 0, 0, 0);
+ NS_STYLE_BORDER_SEPARATE);
const nsCSSValue* borderSpacingValue = aRuleData->ValueForBorderSpacing();
// border-spacing: pair(length), inherit
if (borderSpacingValue->GetUnit() != eCSSUnit_Null) {
nsStyleCoord parentCol(parentTable->mBorderSpacingCol,
nsStyleCoord::CoordConstructor);
nsStyleCoord parentRow(parentTable->mBorderSpacingRow,
nsStyleCoord::CoordConstructor);
@@ -8766,25 +8732,24 @@ nsRuleNode::ComputeTableBorderData(void*
table->mBorderSpacingRow = coordRow.GetCoordValue();
}
// caption-side: enum, inherit, initial
SetValue(*aRuleData->ValueForCaptionSide(),
table->mCaptionSide, conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT,
parentTable->mCaptionSide,
- NS_STYLE_CAPTION_SIDE_TOP, 0, 0, 0, 0);
+ NS_STYLE_CAPTION_SIDE_TOP);
// empty-cells: enum, inherit, initial
SetValue(*aRuleData->ValueForEmptyCells(),
table->mEmptyCells, conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT,
parentTable->mEmptyCells,
- NS_STYLE_TABLE_EMPTY_CELLS_SHOW,
- 0, 0, 0, 0);
+ NS_STYLE_TABLE_EMPTY_CELLS_SHOW);
COMPUTE_END_INHERITED(TableBorder, table)
}
const void*
nsRuleNode::ComputeContentData(void* aStartStruct,
const nsRuleData* aRuleData,
nsStyleContext* aContext,
@@ -9034,51 +8999,50 @@ nsRuleNode::ComputeXULData(void* aStartS
{
COMPUTE_START_RESET(XUL, xul, parentXUL)
// box-align: enum, inherit, initial
SetValue(*aRuleData->ValueForBoxAlign(),
xul->mBoxAlign, conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL,
parentXUL->mBoxAlign,
- NS_STYLE_BOX_ALIGN_STRETCH, 0, 0, 0, 0);
+ NS_STYLE_BOX_ALIGN_STRETCH);
// box-direction: enum, inherit, initial
SetValue(*aRuleData->ValueForBoxDirection(),
xul->mBoxDirection, conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL,
parentXUL->mBoxDirection,
- NS_STYLE_BOX_DIRECTION_NORMAL, 0, 0, 0, 0);
+ NS_STYLE_BOX_DIRECTION_NORMAL);
// box-flex: factor, inherit
SetFactor(*aRuleData->ValueForBoxFlex(),
xul->mBoxFlex, conditions,
parentXUL->mBoxFlex, 0.0f,
SETFCT_UNSET_INITIAL);
// box-orient: enum, inherit, initial
SetValue(*aRuleData->ValueForBoxOrient(),
xul->mBoxOrient, conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL,
parentXUL->mBoxOrient,
- NS_STYLE_BOX_ORIENT_HORIZONTAL, 0, 0, 0, 0);
+ NS_STYLE_BOX_ORIENT_HORIZONTAL);
// box-pack: enum, inherit, initial
SetValue(*aRuleData->ValueForBoxPack(),
xul->mBoxPack, conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL,
parentXUL->mBoxPack,
- NS_STYLE_BOX_PACK_START, 0, 0, 0, 0);
+ NS_STYLE_BOX_PACK_START);
// box-ordinal-group: integer, inherit, initial
SetValue(*aRuleData->ValueForBoxOrdinalGroup(),
xul->mBoxOrdinal, conditions,
SETVAL_INTEGER | SETVAL_UNSET_INITIAL,
- parentXUL->mBoxOrdinal, 1,
- 0, 0, 0, 0);
+ parentXUL->mBoxOrdinal, 1);
const nsCSSValue* stackSizingValue = aRuleData->ValueForStackSizing();
if (eCSSUnit_Inherit == stackSizingValue->GetUnit()) {
conditions.SetUncacheable();
xul->mStretchStack = parentXUL->mStretchStack;
} else if (eCSSUnit_Initial == stackSizingValue->GetUnit() ||
eCSSUnit_Unset == stackSizingValue->GetUnit()) {
xul->mStretchStack = true;
@@ -9211,18 +9175,17 @@ nsRuleNode::ComputeColumnData(void* aSta
column->mColumnRuleColorIsForeground = false;
}
// column-fill: enum
SetValue(*aRuleData->ValueForColumnFill(),
column->mColumnFill, conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL,
parent->mColumnFill,
- NS_STYLE_COLUMN_FILL_BALANCE,
- 0, 0, 0, 0);
+ NS_STYLE_COLUMN_FILL_BALANCE);
COMPUTE_END_RESET(Column, column)
}
static void
SetSVGPaint(const nsCSSValue& aValue, const nsStyleSVGPaint& parentPaint,
nsPresContext* aPresContext, nsStyleContext *aContext,
nsStyleSVGPaint& aResult, nsStyleSVGPaintType aInitialPaintType,
@@ -9323,31 +9286,31 @@ nsRuleNode::ComputeSVGData(void* aStartS
{
COMPUTE_START_INHERITED(SVG, svg, parentSVG)
// clip-rule: enum, inherit, initial
SetValue(*aRuleData->ValueForClipRule(),
svg->mClipRule, conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT,
parentSVG->mClipRule,
- NS_STYLE_FILL_RULE_NONZERO, 0, 0, 0, 0);
+ NS_STYLE_FILL_RULE_NONZERO);
// color-interpolation: enum, inherit, initial
SetValue(*aRuleData->ValueForColorInterpolation(),
svg->mColorInterpolation, conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT,
parentSVG->mColorInterpolation,
- NS_STYLE_COLOR_INTERPOLATION_SRGB, 0, 0, 0, 0);
+ NS_STYLE_COLOR_INTERPOLATION_SRGB);
// color-interpolation-filters: enum, inherit, initial
SetValue(*aRuleData->ValueForColorInterpolationFilters(),
svg->mColorInterpolationFilters, conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT,
parentSVG->mColorInterpolationFilters,
- NS_STYLE_COLOR_INTERPOLATION_LINEARRGB, 0, 0, 0, 0);
+ NS_STYLE_COLOR_INTERPOLATION_LINEARRGB);
// fill:
SetSVGPaint(*aRuleData->ValueForFill(),
parentSVG->mFill, mPresContext, aContext,
svg->mFill, eStyleSVGPaintType_Color, conditions);
// fill-opacity: factor, inherit, initial,
// context-fill-opacity, context-stroke-opacity
@@ -9357,17 +9320,17 @@ nsRuleNode::ComputeSVGData(void* aStartS
parentSVG->mFillOpacity, parentSVG->mFillOpacitySource);
svg->mFillOpacitySource = contextFillOpacity;
// fill-rule: enum, inherit, initial
SetValue(*aRuleData->ValueForFillRule(),
svg->mFillRule, conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT,
parentSVG->mFillRule,
- NS_STYLE_FILL_RULE_NONZERO, 0, 0, 0, 0);
+ NS_STYLE_FILL_RULE_NONZERO);
// marker-end: url, none, inherit
const nsCSSValue* markerEndValue = aRuleData->ValueForMarkerEnd();
if (eCSSUnit_URL == markerEndValue->GetUnit()) {
svg->mMarkerEnd = markerEndValue->GetURLValue();
} else if (eCSSUnit_None == markerEndValue->GetUnit() ||
eCSSUnit_Initial == markerEndValue->GetUnit()) {
svg->mMarkerEnd = nullptr;
@@ -9430,17 +9393,17 @@ nsRuleNode::ComputeSVGData(void* aStartS
NS_NOTREACHED("unexpected unit");
}
// shape-rendering: enum, inherit
SetValue(*aRuleData->ValueForShapeRendering(),
svg->mShapeRendering, conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT,
parentSVG->mShapeRendering,
- NS_STYLE_SHAPE_RENDERING_AUTO, 0, 0, 0, 0);
+ NS_STYLE_SHAPE_RENDERING_AUTO);
// stroke:
SetSVGPaint(*aRuleData->ValueForStroke(),
parentSVG->mStroke, mPresContext, aContext,
svg->mStroke, eStyleSVGPaintType_None, conditions);
// stroke-dasharray: <dasharray>, none, inherit, context-value
const nsCSSValue* strokeDasharrayValue = aRuleData->ValueForStrokeDasharray();
@@ -9513,24 +9476,24 @@ nsRuleNode::ComputeSVGData(void* aStartS
aContext, mPresContext, conditions);
}
// stroke-linecap: enum, inherit, initial
SetValue(*aRuleData->ValueForStrokeLinecap(),
svg->mStrokeLinecap, conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT,
parentSVG->mStrokeLinecap,
- NS_STYLE_STROKE_LINECAP_BUTT, 0, 0, 0, 0);
+ NS_STYLE_STROKE_LINECAP_BUTT);
// stroke-linejoin: enum, inherit, initial
SetValue(*aRuleData->ValueForStrokeLinejoin(),
svg->mStrokeLinejoin, conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT,
parentSVG->mStrokeLinejoin,
- NS_STYLE_STROKE_LINEJOIN_MITER, 0, 0, 0, 0);
+ NS_STYLE_STROKE_LINEJOIN_MITER);
// stroke-miterlimit: <miterlimit>, inherit
SetFactor(*aRuleData->ValueForStrokeMiterlimit(),
svg->mStrokeMiterlimit,
conditions,
parentSVG->mStrokeMiterlimit, 4.0f,
SETFCT_UNSET_INHERIT);
@@ -9565,17 +9528,17 @@ nsRuleNode::ComputeSVGData(void* aStartS
aContext, mPresContext, conditions);
}
// text-anchor: enum, inherit, initial
SetValue(*aRuleData->ValueForTextAnchor(),
svg->mTextAnchor, conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INHERIT,
parentSVG->mTextAnchor,
- NS_STYLE_TEXT_ANCHOR_START, 0, 0, 0, 0);
+ NS_STYLE_TEXT_ANCHOR_START);
COMPUTE_END_INHERITED(SVG, svg)
}
already_AddRefed<nsStyleBasicShape>
nsRuleNode::GetStyleBasicShapeFromCSSValue(const nsCSSValue& aValue,
nsStyleContext* aStyleContext,
nsPresContext* aPresContext,
@@ -9913,33 +9876,33 @@ nsRuleNode::ComputeSVGResetData(void* aS
SETFCT_OPACITY | SETFCT_UNSET_INITIAL);
// dominant-baseline: enum, inherit, initial
SetValue(*aRuleData->ValueForDominantBaseline(),
svgReset->mDominantBaseline,
conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL,
parentSVGReset->mDominantBaseline,
- NS_STYLE_DOMINANT_BASELINE_AUTO, 0, 0, 0, 0);
+ NS_STYLE_DOMINANT_BASELINE_AUTO);
// vector-effect: enum, inherit, initial
SetValue(*aRuleData->ValueForVectorEffect(),
svgReset->mVectorEffect,
conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL,
parentSVGReset->mVectorEffect,
- NS_STYLE_VECTOR_EFFECT_NONE, 0, 0, 0, 0);
+ NS_STYLE_VECTOR_EFFECT_NONE);
// mask-type: enum, inherit, initial
SetValue(*aRuleData->ValueForMaskType(),
svgReset->mMaskType,
conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL,
parentSVGReset->mMaskType,
- NS_STYLE_MASK_TYPE_LUMINANCE, 0, 0, 0, 0);
+ NS_STYLE_MASK_TYPE_LUMINANCE);
#ifdef MOZ_ENABLE_MASK_AS_SHORTHAND
uint32_t maxItemCount = 1;
bool rebuild = false;
// mask-image: none | <url> | <image-list> | <element-reference> | <gradient>
nsStyleImage initialImage;
SetImageLayerList(aContext, *aRuleData->ValueForMaskImage(),
@@ -10272,18 +10235,17 @@ nsRuleNode::ComputeEffectsData(void* aSt
SetFactor(*aRuleData->ValueForOpacity(), effects->mOpacity, conditions,
parentEffects->mOpacity, 1.0f,
SETFCT_OPACITY | SETFCT_UNSET_INITIAL);
// mix-blend-mode: enum, inherit, initial
SetValue(*aRuleData->ValueForMixBlendMode(), effects->mMixBlendMode,
conditions,
SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL,
- parentEffects->mMixBlendMode, NS_STYLE_BLEND_NORMAL,
- 0, 0, 0, 0);
+ parentEffects->mMixBlendMode, NS_STYLE_BLEND_NORMAL);
COMPUTE_END_RESET(Effects, effects)
}
const void*
nsRuleNode::GetStyleData(nsStyleStructID aSID,
nsStyleContext* aContext,
bool aComputeData)