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 324790 1f8b79672ffe480a2414844e398ab3101336e0fa
parent 324789 4e6d4982db0ba1ecb9eca96aad9db606a9714f47
child 324791 ecdb77ae56812fff63dc9bd7633bc976b2813980
push id9671
push userraliiev@mozilla.com
push dateMon, 06 Jun 2016 20:27:52 +0000
treeherdermozilla-aurora@cea65ca3d0bd [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersdbaron
bugs1224918
milestone49.0a1
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)