Bug 1224918 part 2 - Remove SETDCT_{AUTO,NONE,NORMAL,SYSTEM_FONT} and use Unused to indicate unsupported units. r=dbaron
authorXidorn Quan <me@upsuper.org>
Wed, 01 Jun 2016 15:50:32 +1000
changeset 300324 1f8b79672ffe480a2414844e398ab3101336e0fa
parent 300323 4e6d4982db0ba1ecb9eca96aad9db606a9714f47
child 300325 ecdb77ae56812fff63dc9bd7633bc976b2813980
push id30309
push usercbook@mozilla.com
push dateFri, 03 Jun 2016 10:00:40 +0000
treeherdermozilla-central@e27fe24a746f [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersdbaron
bugs1224918
milestone49.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1224918 part 2 - Remove SETDCT_{AUTO,NONE,NORMAL,SYSTEM_FONT} and use Unused to indicate unsupported units. r=dbaron MozReview-Commit-ID: 2OjVfafdgG6
layout/style/nsRuleNode.cpp
--- 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)