Backed out changesets dcdb85fc5517, 702bca0deee2, 9cKX8gC1ATA (bug 1293739) for build bustage; a=bustage
authorGregory Szorc <gps@mozilla.com>
Tue, 16 Aug 2016 17:50:40 -0700
changeset 309640 8c3529c5f60a1b292eaa981b07c27091040a04cc
parent 309639 ad3c62c42039ebc7997b4e92250b14c8689b1bf2
child 309641 84ad59b127a8f1c2cc748e5c7e8613dd34f22c5b
push id30567
push usergszorc@mozilla.com
push dateWed, 17 Aug 2016 00:55:10 +0000
treeherdermozilla-central@8c3529c5f60a [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersbustage
bugs1293739
milestone51.0a1
backs outdcdb85fc5517a3e8769d4925dc394a004eb2625b
702bca0deee2dbe875029264fedfc5995bf6dbfd
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
Backed out changesets dcdb85fc5517, 702bca0deee2, 9cKX8gC1ATA (bug 1293739) for build bustage; a=bustage The merge from inbound to central conflicted with the merge from autoland to central, it appears. Per tree rules, the commit from the autoland repo wins and the inbound commit gets backed out. CLOSED TREE
dom/animation/AnimValuesStyleRule.h
dom/animation/Animation.cpp
dom/animation/Animation.h
dom/animation/EffectCompositor.cpp
dom/animation/EffectCompositor.h
dom/animation/KeyframeEffect.cpp
dom/animation/KeyframeEffect.h
dom/animation/KeyframeEffectParams.cpp
dom/animation/KeyframeEffectParams.h
dom/animation/KeyframeUtils.cpp
dom/animation/KeyframeUtils.h
dom/base/nsDOMWindowUtils.cpp
dom/base/nsTreeSanitizer.cpp
dom/canvas/CanvasRenderingContext2D.cpp
dom/html/HTMLHRElement.cpp
dom/smil/nsSMILAnimationController.cpp
dom/smil/nsSMILCSSProperty.cpp
dom/smil/nsSMILCSSProperty.h
dom/smil/nsSMILCSSValueType.cpp
dom/smil/nsSMILCSSValueType.h
dom/smil/nsSMILCompositor.cpp
dom/smil/nsSMILMappedAttribute.h
dom/svg/nsSVGElement.cpp
editor/libeditor/CSSEditUtils.cpp
gfx/layers/Layers.h
gfx/layers/ipc/LayersMessages.ipdlh
ipc/glue/IPCMessageUtils.h
layout/base/ActiveLayerTracker.cpp
layout/base/ActiveLayerTracker.h
layout/base/FrameLayerBuilder.cpp
layout/base/nsDisplayList.cpp
layout/base/nsDisplayList.h
layout/base/nsLayoutUtils.cpp
layout/base/nsLayoutUtils.h
layout/generic/TextOverflow.cpp
layout/generic/nsIFrame.h
layout/generic/nsTextFrame.cpp
layout/inspector/inCSSValueSearch.cpp
layout/inspector/inCSSValueSearch.h
layout/inspector/inDOMUtils.cpp
layout/mathml/nsMathMLChar.cpp
layout/mathml/nsMathMLFrame.cpp
layout/mathml/nsMathMLmencloseFrame.cpp
layout/mathml/nsMathMLmfracFrame.cpp
layout/style/AnimationCommon.cpp
layout/style/CSSVariableImageTable.h
layout/style/Declaration.cpp
layout/style/Declaration.h
layout/style/FontFace.cpp
layout/style/FontFace.h
layout/style/GenerateCSSPropsGenerated.py
layout/style/LayerAnimationInfo.cpp
layout/style/LayerAnimationInfo.h
layout/style/StyleAnimationValue.cpp
layout/style/StyleAnimationValue.h
layout/style/moz.build
layout/style/nsAnimationManager.cpp
layout/style/nsCSSDataBlock.cpp
layout/style/nsCSSDataBlock.h
layout/style/nsCSSParser.cpp
layout/style/nsCSSParser.h
layout/style/nsCSSPropList.h
layout/style/nsCSSProperty.h
layout/style/nsCSSPropertyID.h
layout/style/nsCSSPropertyIDSet.h
layout/style/nsCSSPropertySet.h
layout/style/nsCSSProps.cpp
layout/style/nsCSSProps.h
layout/style/nsCSSRules.cpp
layout/style/nsCSSRules.h
layout/style/nsCSSValue.cpp
layout/style/nsCSSValue.h
layout/style/nsComputedDOMStyle.cpp
layout/style/nsComputedDOMStylePropertyList.h
layout/style/nsDOMCSSAttrDeclaration.cpp
layout/style/nsDOMCSSAttrDeclaration.h
layout/style/nsDOMCSSDeclaration.cpp
layout/style/nsDOMCSSDeclaration.h
layout/style/nsICSSDeclaration.h
layout/style/nsIStyleRule.h
layout/style/nsRuleData.h
layout/style/nsRuleNode.cpp
layout/style/nsRuleNode.h
layout/style/nsStyleContext.cpp
layout/style/nsStyleContext.h
layout/style/nsStyleStruct.cpp
layout/style/nsStyleStruct.h
layout/style/nsStyleUtil.cpp
layout/style/nsStyleUtil.h
layout/style/nsTransitionManager.cpp
layout/style/nsTransitionManager.h
layout/style/test/TestCSSPropertyLookup.cpp
--- a/dom/animation/AnimValuesStyleRule.h
+++ b/dom/animation/AnimValuesStyleRule.h
@@ -3,18 +3,18 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef mozilla_AnimValuesStyleRule_h
 #define mozilla_AnimValuesStyleRule_h
 
 #include "mozilla/StyleAnimationValue.h"
-#include "nsCSSPropertyID.h"
-#include "nsCSSPropertyIDSet.h"
+#include "nsCSSProperty.h"
+#include "nsCSSPropertySet.h"
 #include "nsIStyleRule.h"
 #include "nsISupportsImpl.h" // For NS_DECL_ISUPPORTS
 #include "nsRuleNode.h" // For nsCachedStyleData
 #include "nsTArray.h" // For nsTArray
 
 namespace mozilla {
 
 /**
@@ -33,25 +33,25 @@ public:
   void MapRuleInfoInto(nsRuleData* aRuleData) override;
   bool MightMapInheritedStyleData() override;
   bool GetDiscretelyAnimatedCSSValue(nsCSSProperty aProperty,
                                      nsCSSValue* aValue) override;
 #ifdef DEBUG
   void List(FILE* out = stdout, int32_t aIndent = 0) const override;
 #endif
 
-  void AddValue(nsCSSPropertyID aProperty, const StyleAnimationValue &aStartValue)
+  void AddValue(nsCSSProperty aProperty, const StyleAnimationValue &aStartValue)
   {
     PropertyStyleAnimationValuePair pair = { aProperty, aStartValue };
     mPropertyValuePairs.AppendElement(pair);
     mStyleBits |=
       nsCachedStyleData::GetBitForSID(nsCSSProps::kSIDTable[aProperty]);
   }
 
-  void AddValue(nsCSSPropertyID aProperty, StyleAnimationValue&& aStartValue)
+  void AddValue(nsCSSProperty aProperty, StyleAnimationValue&& aStartValue)
   {
     PropertyStyleAnimationValuePair* pair = mPropertyValuePairs.AppendElement();
     pair->mProperty = aProperty;
     pair->mValue = Move(aStartValue);
     mStyleBits |=
       nsCachedStyleData::GetBitForSID(nsCSSProps::kSIDTable[aProperty]);
   }
 
--- a/dom/animation/Animation.cpp
+++ b/dom/animation/Animation.cpp
@@ -764,17 +764,17 @@ Animation::HasLowerCompositeOrderThan(co
 
   // 3. Finally, generic animations sort by their position in the global
   // animation array.
   return mAnimationIndex < aOther.mAnimationIndex;
 }
 
 void
 Animation::ComposeStyle(RefPtr<AnimValuesStyleRule>& aStyleRule,
-                        nsCSSPropertyIDSet& aSetProperties)
+                        nsCSSPropertySet& aSetProperties)
 {
   if (!mEffect) {
     return;
   }
 
   if (!IsInEffect()) {
     return;
   }
--- a/dom/animation/Animation.h
+++ b/dom/animation/Animation.h
@@ -13,32 +13,32 @@
 #include "mozilla/EffectCompositor.h" // For EffectCompositor::CascadeLevel
 #include "mozilla/LinkedList.h"
 #include "mozilla/TimeStamp.h" // for TimeStamp, TimeDuration
 #include "mozilla/dom/AnimationBinding.h" // for AnimationPlayState
 #include "mozilla/dom/AnimationTimeline.h" // for AnimationTimeline
 #include "mozilla/DOMEventTargetHelper.h" // for DOMEventTargetHelper
 #include "mozilla/dom/KeyframeEffect.h" // for KeyframeEffectReadOnly
 #include "mozilla/dom/Promise.h" // for Promise
-#include "nsCSSPropertyID.h" // for nsCSSPropertyID
+#include "nsCSSProperty.h" // for nsCSSProperty
 #include "nsIGlobalObject.h"
 
 // X11 has a #define for CurrentTime.
 #ifdef CurrentTime
 #undef CurrentTime
 #endif
 
 // GetCurrentTime is defined in winbase.h as zero argument macro forwarding to
 // GetTickCount().
 #ifdef GetCurrentTime
 #undef GetCurrentTime
 #endif
 
 struct JSContext;
-class nsCSSPropertyIDSet;
+class nsCSSPropertySet;
 class nsIDocument;
 class nsPresContext;
 
 namespace mozilla {
 
 class AnimValuesStyleRule;
 
 namespace dom {
@@ -308,17 +308,17 @@ public:
   bool CanThrottle() const;
   /**
    * Updates |aStyleRule| with the animation values of this animation's effect,
    * if any.
    * Any properties already contained in |aSetProperties| are not changed. Any
    * properties that are changed are added to |aSetProperties|.
    */
   void ComposeStyle(RefPtr<AnimValuesStyleRule>& aStyleRule,
-                    nsCSSPropertyIDSet& aSetProperties);
+                    nsCSSPropertySet& aSetProperties);
 
   void NotifyEffectTimingUpdated();
 
 protected:
   void SilentlySetCurrentTime(const TimeDuration& aNewCurrentTime);
   void SilentlySetPlaybackRate(double aPlaybackRate);
   void CancelNoUpdate();
   void PlayNoUpdate(ErrorResult& aRv, LimitBehavior aLimitBehavior);
--- a/dom/animation/EffectCompositor.cpp
+++ b/dom/animation/EffectCompositor.cpp
@@ -13,17 +13,17 @@
 #include "mozilla/AnimationTarget.h"
 #include "mozilla/AnimationUtils.h"
 #include "mozilla/EffectSet.h"
 #include "mozilla/InitializerList.h"
 #include "mozilla/LayerAnimationInfo.h"
 #include "mozilla/RestyleManagerHandle.h"
 #include "mozilla/RestyleManagerHandleInlines.h"
 #include "nsComputedDOMStyle.h" // nsComputedDOMStyle::GetPresShellForContent
-#include "nsCSSPropertyIDSet.h"
+#include "nsCSSPropertySet.h"
 #include "nsCSSProps.h"
 #include "nsIPresShell.h"
 #include "nsLayoutUtils.h"
 #include "nsRuleNode.h" // For nsRuleNode::ComputePropertiesOverridingAnimation
 #include "nsRuleProcessorData.h" // For ElementRuleProcessorData etc.
 #include "nsTArray.h"
 
 using mozilla::dom::Animation;
@@ -56,17 +56,17 @@ NS_IMPL_CYCLE_COLLECTION_UNROOT_NATIVE(E
 // Helper function to factor out the common logic from
 // GetAnimationsForCompositor and HasAnimationsForCompositor.
 //
 // Takes an optional array to fill with eligible animations.
 //
 // Returns true if there are eligible animations, false otherwise.
 bool
 FindAnimationsForCompositor(const nsIFrame* aFrame,
-                            nsCSSPropertyID aProperty,
+                            nsCSSProperty aProperty,
                             nsTArray<RefPtr<dom::Animation>>* aMatches /*out*/)
 {
   MOZ_ASSERT(!aMatches || aMatches->IsEmpty(),
              "Matches array, if provided, should be empty");
 
   EffectSet* effects = EffectSet::GetEffectSet(aFrame);
   if (!effects || effects->IsEmpty()) {
     return false;
@@ -428,40 +428,40 @@ EffectCompositor::AddStyleUpdatesTo(Rest
 
     elementSet.Clear();
     // Note: mElement pointers in elementsToRestyle might now dangle
   }
 }
 
 /* static */ bool
 EffectCompositor::HasAnimationsForCompositor(const nsIFrame* aFrame,
-                                             nsCSSPropertyID aProperty)
+                                             nsCSSProperty aProperty)
 {
   return FindAnimationsForCompositor(aFrame, aProperty, nullptr);
 }
 
 /* static */ nsTArray<RefPtr<dom::Animation>>
 EffectCompositor::GetAnimationsForCompositor(const nsIFrame* aFrame,
-                                             nsCSSPropertyID aProperty)
+                                             nsCSSProperty aProperty)
 {
   nsTArray<RefPtr<dom::Animation>> result;
 
 #ifdef DEBUG
   bool foundSome =
 #endif
     FindAnimationsForCompositor(aFrame, aProperty, &result);
   MOZ_ASSERT(!foundSome || !result.IsEmpty(),
              "If return value is true, matches array should be non-empty");
 
   return result;
 }
 
 /* static */ void
 EffectCompositor::ClearIsRunningOnCompositor(const nsIFrame *aFrame,
-                                             nsCSSPropertyID aProperty)
+                                             nsCSSProperty aProperty)
 {
   EffectSet* effects = EffectSet::GetEffectSet(aFrame);
   if (!effects) {
     return;
   }
 
   for (KeyframeEffectReadOnly* effect : *effects) {
     effect->SetIsRunningOnCompositor(aProperty, false);
@@ -593,37 +593,37 @@ EffectCompositor::ComposeAnimationRule(d
   RefPtr<AnimValuesStyleRule>& animationRule =
     effects->AnimationRule(aCascadeLevel);
   animationRule = nullptr;
 
   // If multiple animations specify behavior for the same property the
   // animation with the *highest* composite order wins.
   // As a result, we iterate from last animation to first and, if a
   // property has already been set, we don't change it.
-  nsCSSPropertyIDSet properties;
+  nsCSSPropertySet properties;
 
   for (KeyframeEffectReadOnly* effect : Reversed(sortedEffectList)) {
     effect->GetAnimation()->ComposeStyle(animationRule, properties);
   }
 
   MOZ_ASSERT(effects == EffectSet::GetEffectSet(aElement, aPseudoType),
              "EffectSet should not change while composing style");
 
   effects->UpdateAnimationRuleRefreshTime(aCascadeLevel, aRefreshTime);
 }
 
 /* static */ void
 EffectCompositor::GetOverriddenProperties(nsStyleContext* aStyleContext,
                                           EffectSet& aEffectSet,
-                                          nsCSSPropertyIDSet&
+                                          nsCSSPropertySet&
                                             aPropertiesOverridden)
 {
-  AutoTArray<nsCSSPropertyID, LayerAnimationInfo::kRecords> propertiesToTrack;
+  AutoTArray<nsCSSProperty, LayerAnimationInfo::kRecords> propertiesToTrack;
   {
-    nsCSSPropertyIDSet propertiesToTrackAsSet;
+    nsCSSPropertySet propertiesToTrackAsSet;
     for (KeyframeEffectReadOnly* effect : aEffectSet) {
       for (const AnimationProperty& property : effect->Properties()) {
         if (nsCSSProps::PropHasFlags(property.mProperty,
                                      CSS_PROPERTY_CAN_ANIMATE_ON_COMPOSITOR) &&
             !propertiesToTrackAsSet.HasProperty(property.mProperty)) {
           propertiesToTrackAsSet.AddProperty(property.mProperty);
           propertiesToTrack.AppendElement(property.mProperty);
         }
@@ -665,23 +665,23 @@ EffectCompositor::UpdateCascadeResults(E
   }
   sortedEffectList.Sort(EffectCompositeOrderComparator());
 
   // Get properties that override the *animations* level of the cascade.
   //
   // We only do this for properties that we can animate on the compositor
   // since we will apply other properties on the main thread where the usual
   // cascade applies.
-  nsCSSPropertyIDSet overriddenProperties;
+  nsCSSPropertySet overriddenProperties;
   if (aStyleContext) {
     GetOverriddenProperties(aStyleContext, aEffectSet, overriddenProperties);
   }
 
   bool changed = false;
-  nsCSSPropertyIDSet animatedProperties;
+  nsCSSPropertySet animatedProperties;
 
   // Iterate from highest to lowest composite order.
   for (KeyframeEffectReadOnly* effect : Reversed(sortedEffectList)) {
     MOZ_ASSERT(effect->GetAnimation(),
                "Effects on a target element should have an Animation");
     bool inEffect = effect->IsInEffect();
     for (AnimationProperty& prop : effect->Properties()) {
 
@@ -743,17 +743,17 @@ EffectCompositor::GetPresContext(Element
     return nullptr;
   }
   return shell->GetPresContext();
 }
 
 /* static */ void
 EffectCompositor::SetPerformanceWarning(
   const nsIFrame *aFrame,
-  nsCSSPropertyID aProperty,
+  nsCSSProperty aProperty,
   const AnimationPerformanceWarning& aWarning)
 {
   EffectSet* effects = EffectSet::GetEffectSet(aFrame);
   if (!effects) {
     return;
   }
 
   for (KeyframeEffectReadOnly* effect : *effects) {
--- a/dom/animation/EffectCompositor.h
+++ b/dom/animation/EffectCompositor.h
@@ -7,23 +7,23 @@
 #ifndef mozilla_EffectCompositor_h
 #define mozilla_EffectCompositor_h
 
 #include "mozilla/EnumeratedArray.h"
 #include "mozilla/Maybe.h"
 #include "mozilla/OwningNonNull.h"
 #include "mozilla/PseudoElementHashEntry.h"
 #include "mozilla/RefPtr.h"
-#include "nsCSSPropertyID.h"
+#include "nsCSSProperty.h"
 #include "nsCycleCollectionParticipant.h"
 #include "nsDataHashtable.h"
 #include "nsIStyleRuleProcessor.h"
 #include "nsTArray.h"
 
-class nsCSSPropertyIDSet;
+class nsCSSPropertySet;
 class nsIFrame;
 class nsIStyleRule;
 class nsPresContext;
 class nsStyleContext;
 
 namespace mozilla {
 
 class EffectSet;
@@ -157,24 +157,24 @@ public:
   void AddStyleUpdatesTo(RestyleTracker& aTracker);
 
   nsIStyleRuleProcessor* RuleProcessor(CascadeLevel aCascadeLevel) const
   {
     return mRuleProcessors[aCascadeLevel];
   }
 
   static bool HasAnimationsForCompositor(const nsIFrame* aFrame,
-                                         nsCSSPropertyID aProperty);
+                                         nsCSSProperty aProperty);
 
   static nsTArray<RefPtr<dom::Animation>>
   GetAnimationsForCompositor(const nsIFrame* aFrame,
-                             nsCSSPropertyID aProperty);
+                             nsCSSProperty aProperty);
 
   static void ClearIsRunningOnCompositor(const nsIFrame* aFrame,
-                                         nsCSSPropertyID aProperty);
+                                         nsCSSProperty aProperty);
 
   // Update animation cascade results for the specified (pseudo-)element
   // but only if we have marked the cascade as needing an update due a
   // the change in the set of effects or a change in one of the effects'
   // "in effect" state.
   // |aStyleContext| may be nullptr in which case we will use the
   // nsStyleContext of the primary frame of the specified (pseudo-)element.
   //
@@ -207,17 +207,17 @@ public:
   // animations.
   static Maybe<NonOwningAnimationTarget>
   GetAnimationElementAndPseudoForFrame(const nsIFrame* aFrame);
 
   // Associates a performance warning with effects on |aFrame| that animates
   // |aProperty|.
   static void SetPerformanceWarning(
     const nsIFrame* aFrame,
-    nsCSSPropertyID aProperty,
+    nsCSSProperty aProperty,
     const AnimationPerformanceWarning& aWarning);
 
 private:
   ~EffectCompositor() = default;
 
   // Rebuilds the animation rule corresponding to |aCascadeLevel| on the
   // EffectSet associated with the specified (pseudo-)element.
   static void ComposeAnimationRule(dom::Element* aElement,
@@ -230,17 +230,17 @@ private:
                                              aPseudoType);
 
   // Get the properties in |aEffectSet| that we are able to animate on the
   // compositor but which are also specified at a higher level in the cascade
   // than the animations level in |aStyleContext|.
   static void
   GetOverriddenProperties(nsStyleContext* aStyleContext,
                           EffectSet& aEffectSet,
-                          nsCSSPropertyIDSet& aPropertiesOverridden);
+                          nsCSSPropertySet& aPropertiesOverridden);
 
   static void
   UpdateCascadeResults(EffectSet& aEffectSet,
                        dom::Element* aElement,
                        CSSPseudoElementType aPseudoType,
                        nsStyleContext* aStyleContext);
 
   static nsPresContext* GetPresContext(dom::Element* aElement);
--- a/dom/animation/KeyframeEffect.cpp
+++ b/dom/animation/KeyframeEffect.cpp
@@ -11,17 +11,17 @@
 #include "mozilla/AnimationUtils.h"
 #include "mozilla/FloatingPoint.h"
 #include "mozilla/LookAndFeel.h" // For LookAndFeel::GetInt
 #include "mozilla/KeyframeUtils.h"
 #include "mozilla/StyleAnimationValue.h"
 #include "Layers.h" // For Layer
 #include "nsComputedDOMStyle.h" // nsComputedDOMStyle::GetStyleContextForElement
 #include "nsContentUtils.h"  // nsContentUtils::ReportToConsole
-#include "nsCSSPropertyIDSet.h"
+#include "nsCSSPropertySet.h"
 #include "nsCSSProps.h" // For nsCSSProps::PropHasFlags
 #include "nsCSSPseudoElements.h" // For CSSPseudoElementType
 #include "nsDOMMutationObserver.h" // For nsAutoAnimationMutationBatch
 #include "nsIPresShell.h" // For nsIPresShell
 #include "nsIScriptError.h"
 
 namespace mozilla {
 
@@ -487,17 +487,17 @@ KeyframeEffectReadOnly::SetKeyframes(nsT
 
   if (aStyleContext) {
     UpdateProperties(aStyleContext);
     MaybeUpdateFrameForCompositor();
   }
 }
 
 const AnimationProperty*
-KeyframeEffectReadOnly::GetAnimationOfProperty(nsCSSPropertyID aProperty) const
+KeyframeEffectReadOnly::GetAnimationOfProperty(nsCSSProperty aProperty) const
 {
   for (size_t propIdx = 0, propEnd = mProperties.Length();
        propIdx != propEnd; ++propIdx) {
     if (aProperty == mProperties[propIdx].mProperty) {
       const AnimationProperty* result = &mProperties[propIdx];
       if (!result->mWinsInCascade) {
         result = nullptr;
       }
@@ -570,18 +570,18 @@ KeyframeEffectReadOnly::UpdateProperties
     mKeyframes.SwapElements(keyframesCopy);
   }
 
   if (mProperties == properties) {
     return;
   }
 
   // Preserve the state of mWinsInCascade and mIsRunningOnCompositor flags.
-  nsCSSPropertyIDSet winningInCascadeProperties;
-  nsCSSPropertyIDSet runningOnCompositorProperties;
+  nsCSSPropertySet winningInCascadeProperties;
+  nsCSSPropertySet runningOnCompositorProperties;
 
   for (const AnimationProperty& property : mProperties) {
     if (property.mWinsInCascade) {
       winningInCascadeProperties.AddProperty(property.mProperty);
     }
     if (property.mIsRunningOnCompositor) {
       runningOnCompositorProperties.AddProperty(property.mProperty);
     }
@@ -606,17 +606,17 @@ KeyframeEffectReadOnly::UpdateProperties
     }
 
     RequestRestyle(EffectCompositor::RestyleType::Layer);
   }
 }
 
 void
 KeyframeEffectReadOnly::ComposeStyle(RefPtr<AnimValuesStyleRule>& aStyleRule,
-                                     nsCSSPropertyIDSet& aSetProperties)
+                                     nsCSSPropertySet& aSetProperties)
 {
   ComputedTiming computedTiming = GetComputedTiming();
   mProgressOnLastCompose = computedTiming.mProgress;
 
   // If the progress is null, we don't have fill data for the current
   // time so we shouldn't animate.
   if (computedTiming.mProgress.IsNull()) {
     return;
@@ -720,17 +720,17 @@ KeyframeEffectReadOnly::IsRunningOnCompo
     if (property.mIsRunningOnCompositor) {
       return true;
     }
   }
   return false;
 }
 
 void
-KeyframeEffectReadOnly::SetIsRunningOnCompositor(nsCSSPropertyID aProperty,
+KeyframeEffectReadOnly::SetIsRunningOnCompositor(nsCSSProperty aProperty,
                                                  bool aIsRunning)
 {
   MOZ_ASSERT(nsCSSProps::PropHasFlags(aProperty,
                                       CSS_PROPERTY_CAN_ANIMATE_ON_COMPOSITOR),
              "Property being animated on compositor is a recognized "
              "compositor-animatable property");
   for (AnimationProperty& property : mProperties) {
     if (property.mProperty == aProperty) {
@@ -1000,17 +1000,17 @@ KeyframeEffectReadOnly::GetTarget(
 
     default:
       NS_NOTREACHED("Animation of unsupported pseudo-type");
       aRv.SetNull();
   }
 }
 
 static void
-CreatePropertyValue(nsCSSPropertyID aProperty,
+CreatePropertyValue(nsCSSProperty aProperty,
                     float aOffset,
                     const Maybe<ComputedTimingFunction>& aTimingFunction,
                     const StyleAnimationValue& aValue,
                     AnimationPropertyValueDetails& aResult)
 {
   aResult.mOffset = aOffset;
 
   nsString stringValue;
@@ -1127,17 +1127,17 @@ KeyframeEffectReadOnly::GetKeyframes(JSC
     JS::Rooted<JSObject*> keyframeObject(aCx, &keyframeJSValue.toObject());
     for (const PropertyValuePair& propertyValue : keyframe.mPropertyValues) {
 
       const char* name = nsCSSProps::PropertyIDLName(propertyValue.mProperty);
 
       // nsCSSValue::AppendToString does not accept shorthands properties but
       // works with token stream values if we pass eCSSProperty_UNKNOWN as
       // the property.
-      nsCSSPropertyID propertyForSerializing =
+      nsCSSProperty propertyForSerializing =
         nsCSSProps::IsShorthand(propertyValue.mProperty)
         ? eCSSProperty_UNKNOWN
         : propertyValue.mProperty;
 
       nsAutoString stringValue;
       propertyValue.mValue.AppendToString(
         propertyForSerializing, stringValue, nsCSSValue::eNormalized);
 
@@ -1347,17 +1347,17 @@ KeyframeEffectReadOnly::GetPresContext()
   if (!shell) {
     return nullptr;
   }
   return shell->GetPresContext();
 }
 
 /* static */ bool
 KeyframeEffectReadOnly::IsGeometricProperty(
-  const nsCSSPropertyID aProperty)
+  const nsCSSProperty aProperty)
 {
   switch (aProperty) {
     case eCSSProperty_bottom:
     case eCSSProperty_height:
     case eCSSProperty_left:
     case eCSSProperty_right:
     case eCSSProperty_top:
     case eCSSProperty_width:
@@ -1433,17 +1433,17 @@ KeyframeEffectReadOnly::ShouldBlockAsync
     }
   }
 
   return false;
 }
 
 void
 KeyframeEffectReadOnly::SetPerformanceWarning(
-  nsCSSPropertyID aProperty,
+  nsCSSProperty aProperty,
   const AnimationPerformanceWarning& aWarning)
 {
   for (AnimationProperty& property : mProperties) {
     if (property.mProperty == aProperty &&
         (!property.mPerformanceWarning ||
          *property.mPerformanceWarning != aWarning)) {
       property.mPerformanceWarning = Some(aWarning);
 
@@ -1454,17 +1454,17 @@ KeyframeEffectReadOnly::SetPerformanceWa
         AnimationUtils::LogAsyncAnimationFailure(logMessage, mTarget->mElement);
       }
       return;
     }
   }
 }
 
 static already_AddRefed<nsStyleContext>
-CreateStyleContextForAnimationValue(nsCSSPropertyID aProperty,
+CreateStyleContextForAnimationValue(nsCSSProperty aProperty,
                                     StyleAnimationValue aValue,
                                     nsStyleContext* aBaseStyleContext)
 {
   MOZ_ASSERT(aBaseStyleContext,
              "CreateStyleContextForAnimationValue needs to be called "
              "with a valid nsStyleContext");
 
   RefPtr<AnimValuesStyleRule> styleRule = new AnimValuesStyleRule();
--- a/dom/animation/KeyframeEffect.h
+++ b/dom/animation/KeyframeEffect.h
@@ -3,17 +3,17 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
  * You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef mozilla_dom_KeyframeEffect_h
 #define mozilla_dom_KeyframeEffect_h
 
 #include "nsChangeHint.h"
-#include "nsCSSPropertyID.h"
+#include "nsCSSProperty.h"
 #include "nsCSSValue.h"
 #include "nsCycleCollectionParticipant.h"
 #include "nsTArray.h"
 #include "nsWrapperCache.h"
 #include "mozilla/AnimationPerformanceWarning.h"
 #include "mozilla/AnimationTarget.h"
 #include "mozilla/Attributes.h"
 #include "mozilla/ComputedTiming.h"
@@ -27,17 +27,17 @@
 #include "mozilla/TimeStamp.h"
 #include "mozilla/TimingParams.h"
 #include "mozilla/dom/AnimationEffectReadOnly.h"
 #include "mozilla/dom/AnimationEffectTimingReadOnly.h"
 #include "mozilla/dom/Element.h"
 #include "mozilla/dom/Nullable.h"
 
 struct JSContext;
-class nsCSSPropertyIDSet;
+class nsCSSPropertySet;
 class nsIContent;
 class nsIDocument;
 class nsIFrame;
 class nsIPresShell;
 class nsPresContext;
 
 namespace mozilla {
 
@@ -54,17 +54,17 @@ enum class CompositeOperation : uint32_t
 struct AnimationPropertyDetails;
 }
 
 /**
  * A property-value pair specified on a keyframe.
  */
 struct PropertyValuePair
 {
-  nsCSSPropertyID mProperty;
+  nsCSSProperty mProperty;
   // The specified value for the property. For shorthand properties or invalid
   // property values, we store the specified property value as a token stream
   // (string).
   nsCSSValue    mValue;
 
   bool operator==(const PropertyValuePair& aOther) const {
     return mProperty == aOther.mProperty &&
            mValue == aOther.mValue;
@@ -129,17 +129,17 @@ struct AnimationPropertySegment
   }
   bool operator!=(const AnimationPropertySegment& aOther) const {
     return !(*this == aOther);
   }
 };
 
 struct AnimationProperty
 {
-  nsCSSPropertyID mProperty = eCSSProperty_UNKNOWN;
+  nsCSSProperty mProperty = eCSSProperty_UNKNOWN;
 
   // Does this property win in the CSS Cascade?
   //
   // For CSS transitions, this is true as long as a CSS animation on the
   // same property and element is not running, in which case we set this
   // to false so that the animation (lower in the cascade) can win.  We
   // then use this to decide whether to apply the style both in the CSS
   // cascade and for OMTA.
@@ -285,18 +285,18 @@ public:
   void SetAnimation(Animation* aAnimation);
   Animation* GetAnimation() const { return mAnimation; }
 
   void SetKeyframes(JSContext* aContext, JS::Handle<JSObject*> aKeyframes,
                     ErrorResult& aRv);
   void SetKeyframes(nsTArray<Keyframe>&& aKeyframes,
                     nsStyleContext* aStyleContext);
   const AnimationProperty*
-  GetAnimationOfProperty(nsCSSPropertyID aProperty) const;
-  bool HasAnimationOfProperty(nsCSSPropertyID aProperty) const {
+  GetAnimationOfProperty(nsCSSProperty aProperty) const;
+  bool HasAnimationOfProperty(nsCSSProperty aProperty) const {
     return GetAnimationOfProperty(aProperty) != nullptr;
   }
   const InfallibleTArray<AnimationProperty>& Properties() const {
     return mProperties;
   }
   InfallibleTArray<AnimationProperty>& Properties() {
     return mProperties;
   }
@@ -305,20 +305,20 @@ public:
   // |aStyleContext| to resolve specified values.
   void UpdateProperties(nsStyleContext* aStyleContext);
 
   // Updates |aStyleRule| with the animation values produced by this
   // AnimationEffect for the current time except any properties already
   // contained in |aSetProperties|.
   // Any updated properties are added to |aSetProperties|.
   void ComposeStyle(RefPtr<AnimValuesStyleRule>& aStyleRule,
-                    nsCSSPropertyIDSet& aSetProperties);
+                    nsCSSPropertySet& aSetProperties);
   // Returns true if at least one property is being animated on compositor.
   bool IsRunningOnCompositor() const;
-  void SetIsRunningOnCompositor(nsCSSPropertyID aProperty, bool aIsRunning);
+  void SetIsRunningOnCompositor(nsCSSProperty aProperty, bool aIsRunning);
   void ResetIsRunningOnCompositor();
 
   // Returns true if this effect, applied to |aFrame|, contains properties
   // that mean we shouldn't run transform compositor animations on this element.
   //
   // For example, if we have an animation of geometric properties like 'left'
   // and 'top' on an element, we force all 'transform' animations running at
   // the same time on the same element to run on the main thread.
@@ -333,17 +333,17 @@ public:
   nsPresContext* GetPresContext() const;
   nsIPresShell* GetPresShell() const;
 
   // Associates a warning with the animated property on the specified frame
   // indicating why, for example, the property could not be animated on the
   // compositor. |aParams| and |aParamsLength| are optional parameters which
   // will be used to generate a localized message for devtools.
   void SetPerformanceWarning(
-    nsCSSPropertyID aProperty,
+    nsCSSProperty aProperty,
     const AnimationPerformanceWarning& aWarning);
 
   // Cumulative change hint on each segment for each property.
   // This is used for deciding the animation is paint-only.
   void CalculateCumulativeChangeHint(nsStyleContext* aStyleContext);
 
   // Returns true if all of animation properties' change hints
   // can ignore painting if the animation is not visible.
@@ -429,17 +429,17 @@ private:
   bool CanThrottleTransformChanges(nsIFrame& aFrame) const;
 
   // Returns true unless Gecko limitations prevent performing transform
   // animations for |aFrame|. When returning true, the reason for the
   // limitation is stored in |aOutPerformanceWarning|.
   static bool CanAnimateTransformOnCompositor(
     const nsIFrame* aFrame,
     AnimationPerformanceWarning::Type& aPerformanceWarning);
-  static bool IsGeometricProperty(const nsCSSPropertyID aProperty);
+  static bool IsGeometricProperty(const nsCSSProperty aProperty);
 
   static const TimeDuration OverflowRegionRefreshInterval();
 };
 
 class KeyframeEffect : public KeyframeEffectReadOnly
 {
 public:
   KeyframeEffect(nsIDocument* aDocument,
--- a/dom/animation/KeyframeEffectParams.cpp
+++ b/dom/animation/KeyframeEffectParams.cpp
@@ -101,17 +101,17 @@ ConsumeIdentToken(RangedPtr<const char16
     }
     ++aIter;
   }
 }
 
 /* static */ void
 KeyframeEffectParams::ParseSpacing(const nsAString& aSpacing,
                                    SpacingMode& aSpacingMode,
-                                   nsCSSPropertyID& aPacedProperty,
+                                   nsCSSProperty& aPacedProperty,
                                    nsAString& aInvalidPacedProperty,
                                    ErrorResult& aRv)
 {
   aInvalidPacedProperty.Truncate();
 
   // Ignore spacing if the core API is not enabled since it is not yet ready to
   // ship.
   if (!AnimationUtils::IsCoreAPIEnabled()) {
--- a/dom/animation/KeyframeEffectParams.h
+++ b/dom/animation/KeyframeEffectParams.h
@@ -40,21 +40,21 @@ struct KeyframeEffectParams
    * @param [out] aInvalidPacedProperty A string that, if we parsed a string of
    *                                    the form 'paced(<ident>)' where <ident>
    *                                    is not a recognized animatable property,
    *                                    will be set to <ident>.
    * @param [out] aRv The error result.
    */
   static void ParseSpacing(const nsAString& aSpacing,
                            SpacingMode& aSpacingMode,
-                           nsCSSPropertyID& aPacedProperty,
+                           nsCSSProperty& aPacedProperty,
                            nsAString& aInvalidPacedProperty,
                            ErrorResult& aRv);
 
   // FIXME: Bug 1216843: Add IterationCompositeOperations and
   //        Bug 1216844: Add CompositeOperation
   SpacingMode mSpacingMode = SpacingMode::distribute;
-  nsCSSPropertyID mPacedProperty = eCSSProperty_UNKNOWN;
+  nsCSSProperty mPacedProperty = eCSSProperty_UNKNOWN;
 };
 
 } // namespace mozilla
 
 #endif // mozilla_KeyframeEffectParams_h
--- a/dom/animation/KeyframeUtils.cpp
+++ b/dom/animation/KeyframeUtils.cpp
@@ -34,17 +34,17 @@ namespace mozilla {
 // we set its cumulative distance to kNotPaceable, so we can use this to check.
 const double kNotPaceable = -1.0;
 
 // For the aAllowList parameter of AppendStringOrStringSequence and
 // GetPropertyValuesPairs.
 enum class ListAllowance { eDisallow, eAllow };
 
 /**
- * A comparator to sort nsCSSPropertyID values such that longhands are sorted
+ * A comparator to sort nsCSSProperty values such that longhands are sorted
  * before shorthands, and shorthands with fewer components are sorted before
  * shorthands with more components.
  *
  * Using this allows us to prioritize values specified by longhands (or smaller
  * shorthand subsets) when longhands and shorthands are both specified
  * on the one keyframe.
  *
  * Example orderings that result from this:
@@ -56,23 +56,23 @@ enum class ListAllowance { eDisallow, eA
  *   border-top-color, border-color, border-top, border
  */
 class PropertyPriorityComparator
 {
 public:
   PropertyPriorityComparator()
     : mSubpropertyCountInitialized(false) {}
 
-  bool Equals(nsCSSPropertyID aLhs, nsCSSPropertyID aRhs) const
+  bool Equals(nsCSSProperty aLhs, nsCSSProperty aRhs) const
   {
     return aLhs == aRhs;
   }
 
-  bool LessThan(nsCSSPropertyID aLhs,
-                nsCSSPropertyID aRhs) const
+  bool LessThan(nsCSSProperty aLhs,
+                nsCSSProperty aRhs) const
   {
     bool isShorthandLhs = nsCSSProps::IsShorthand(aLhs);
     bool isShorthandRhs = nsCSSProps::IsShorthand(aRhs);
 
     if (isShorthandLhs) {
       if (isShorthandRhs) {
         // First, sort shorthands by the number of longhands they have.
         uint32_t subpropCountLhs = SubpropertyCount(aLhs);
@@ -92,17 +92,17 @@ public:
       }
     }
     // For two longhand properties, or two shorthand with the same number
     // of longhand components, sort by IDL name.
     return nsCSSProps::PropertyIDLNameSortPosition(aLhs) <
            nsCSSProps::PropertyIDLNameSortPosition(aRhs);
   }
 
-  uint32_t SubpropertyCount(nsCSSPropertyID aProperty) const
+  uint32_t SubpropertyCount(nsCSSProperty aProperty) const
   {
     if (!mSubpropertyCountInitialized) {
       PodZero(&mSubpropertyCount);
       mSubpropertyCountInitialized = true;
     }
     if (mSubpropertyCount[aProperty] == 0) {
       uint32_t count = 0;
       CSSPROPS_FOR_SHORTHAND_SUBPROPERTIES(
@@ -200,17 +200,17 @@ public:
   };
 
   Iter begin() { return Iter(*this); }
   Iter end()   { return Iter::EndIter(*this); }
 
 private:
   struct PropertyAndIndex
   {
-    nsCSSPropertyID mProperty;
+    nsCSSProperty mProperty;
     size_t mIndex; // Index of mProperty within mProperties
 
     typedef TPropertyPriorityComparator<PropertyAndIndex> Comparator;
   };
 
   const nsTArray<PropertyValuePair>& mProperties;
   nsTArray<PropertyAndIndex> mSortedPropertyIndices;
 };
@@ -220,29 +220,29 @@ private:
  * discovered on a regular keyframe or property-indexed keyframe object.
  *
  * Single values (as required by a regular keyframe, and as also supported
  * on property-indexed keyframes) are stored as the only element in
  * mValues.
  */
 struct PropertyValuesPair
 {
-  nsCSSPropertyID mProperty;
+  nsCSSProperty mProperty;
   nsTArray<nsString> mValues;
 
   typedef TPropertyPriorityComparator<PropertyValuesPair> Comparator;
 };
 
 /**
  * An additional property (for a property-values pair) found on a
  * BaseKeyframe or BasePropertyIndexedKeyframe object.
  */
 struct AdditionalProperty
 {
-  nsCSSPropertyID mProperty;
+  nsCSSProperty mProperty;
   size_t mJsidIndex;        // Index into |ids| in GetPropertyValuesPairs.
 
   struct PropertyComparator
   {
     bool Equals(const AdditionalProperty& aLhs,
                 const AdditionalProperty& aRhs) const
     {
       return aLhs.mProperty == aRhs.mProperty;
@@ -260,17 +260,17 @@ struct AdditionalProperty
  * Data for a segment in a keyframe animation of a given property
  * whose value is a StyleAnimationValue.
  *
  * KeyframeValueEntry is used in GetAnimationPropertiesFromKeyframes
  * to gather data for each individual segment.
  */
 struct KeyframeValueEntry
 {
-  nsCSSPropertyID mProperty;
+  nsCSSProperty mProperty;
   StyleAnimationValue mValue;
   float mOffset;
   Maybe<ComputedTimingFunction> mTimingFunction;
 
   struct PropertyOffsetComparator
   {
     static bool Equals(const KeyframeValueEntry& aLhs,
                        const KeyframeValueEntry& aRhs)
@@ -365,17 +365,17 @@ AppendStringOrStringSequenceToArray(JSCo
                                     nsTArray<nsString>& aValues);
 
 static bool
 AppendValueAsString(JSContext* aCx,
                     nsTArray<nsString>& aValues,
                     JS::Handle<JS::Value> aValue);
 
 static PropertyValuePair
-MakePropertyValuePair(nsCSSPropertyID aProperty, const nsAString& aStringValue,
+MakePropertyValuePair(nsCSSProperty aProperty, const nsAString& aStringValue,
                       nsCSSParser& aParser, nsIDocument* aDocument);
 
 static bool
 HasValidOffsets(const nsTArray<Keyframe>& aKeyframes);
 
 static void
 MarkAsComputeValuesFailureKey(PropertyValuePair& aPair);
 
@@ -406,17 +406,17 @@ static void
 DistributeRange(const Range<Keyframe>& aSpacingRange);
 
 static void
 PaceRange(const Range<Keyframe>& aKeyframes,
           const Range<double>& aCumulativeDistances);
 
 static nsTArray<double>
 GetCumulativeDistances(const nsTArray<ComputedKeyframeValues>& aValues,
-                       nsCSSPropertyID aProperty);
+                       nsCSSProperty aProperty);
 
 // ------------------------------------------------------------------
 //
 // Public API
 //
 // ------------------------------------------------------------------
 
 /* static */ nsTArray<Keyframe>
@@ -469,17 +469,17 @@ KeyframeUtils::GetKeyframesFromObject(JS
   }
 
   return keyframes;
 }
 
 /* static */ void
 KeyframeUtils::ApplySpacing(nsTArray<Keyframe>& aKeyframes,
                             SpacingMode aSpacingMode,
-                            nsCSSPropertyID aProperty,
+                            nsCSSProperty aProperty,
                             nsTArray<ComputedKeyframeValues>& aComputedValues)
 {
   if (aKeyframes.IsEmpty()) {
     return;
   }
 
   nsTArray<double> cumulativeDistances;
   if (aSpacingMode == SpacingMode::paced) {
@@ -587,17 +587,17 @@ KeyframeUtils::GetComputedKeyframeValues
 {
   MOZ_ASSERT(aStyleContext);
   MOZ_ASSERT(aElement);
 
   const size_t len = aKeyframes.Length();
   nsTArray<ComputedKeyframeValues> result(len);
 
   for (const Keyframe& frame : aKeyframes) {
-    nsCSSPropertyIDSet propertiesOnThisKeyframe;
+    nsCSSPropertySet propertiesOnThisKeyframe;
     ComputedKeyframeValues* computedValues = result.AppendElement();
     for (const PropertyValuePair& pair :
            PropertyPriorityIterator(frame.mPropertyValues)) {
       if (IsInvalidValuePair(pair)) {
         continue;
       }
 
       // Expand each value into the set of longhands and produce
@@ -667,17 +667,17 @@ KeyframeUtils::GetAnimationPropertiesFro
   }
 
   nsTArray<AnimationProperty> result;
   BuildSegmentsFromValueEntries(aStyleContext, entries, result);
   return result;
 }
 
 /* static */ bool
-KeyframeUtils::IsAnimatableProperty(nsCSSPropertyID aProperty)
+KeyframeUtils::IsAnimatableProperty(nsCSSProperty aProperty)
 {
   if (aProperty == eCSSProperty_UNKNOWN) {
     return false;
   }
 
   if (!nsCSSProps::IsShorthand(aProperty)) {
     return nsCSSProps::kAnimTypeTable[aProperty] != eStyleAnimType_None;
   }
@@ -858,17 +858,17 @@ GetPropertyValuesPairs(JSContext* aCx,
   if (!JS_Enumerate(aCx, aObject, &ids)) {
     return false;
   }
   for (size_t i = 0, n = ids.length(); i < n; i++) {
     nsAutoJSString propName;
     if (!propName.init(aCx, ids[i])) {
       return false;
     }
-    nsCSSPropertyID property =
+    nsCSSProperty property =
       nsCSSProps::LookupPropertyByIDLName(propName,
                                           CSSEnabledState::eForAllContent);
     if (KeyframeUtils::IsAnimatableProperty(property)) {
       AdditionalProperty* p = properties.AppendElement();
       p->mProperty = property;
       p->mJsidIndex = i;
     }
   }
@@ -959,17 +959,17 @@ AppendValueAsString(JSContext* aCx,
  *
  * @param aProperty The CSS property.
  * @param aStringValue The property value to parse.
  * @param aParser The CSS parser object to use.
  * @param aDocument The document to use when parsing.
  * @return The constructed PropertyValuePair object.
  */
 static PropertyValuePair
-MakePropertyValuePair(nsCSSPropertyID aProperty, const nsAString& aStringValue,
+MakePropertyValuePair(nsCSSProperty aProperty, const nsAString& aStringValue,
                       nsCSSParser& aParser, nsIDocument* aDocument)
 {
   MOZ_ASSERT(aDocument);
 
   nsCSSValue value;
   if (!nsCSSProps::IsShorthand(aProperty)) {
     aParser.ParseLonghandProperty(aProperty,
                                   aStringValue,
@@ -1111,17 +1111,17 @@ BuildSegmentsFromValueEntries(nsStyleCon
   // one KeyframeValueEntry with offset 0.0, and at least one with offset 1.0.
   // However, since it is possible that when building |aEntries|, the call to
   // StyleAnimationValue::ComputeValues might fail, this can't be guaranteed.
   // Furthermore, since we don't yet implement additive animation and hence
   // don't have sensible fallback behavior when these values are missing, the
   // following loop takes care to identify properties that lack a value at
   // offset 0.0/1.0 and drops those properties from |aResult|.
 
-  nsCSSPropertyID lastProperty = eCSSProperty_UNKNOWN;
+  nsCSSProperty lastProperty = eCSSProperty_UNKNOWN;
   AnimationProperty* animationProperty = nullptr;
 
   size_t i = 0, n = aEntries.Length();
 
   while (i < n) {
     // Check that the last property ends with an entry at offset 1.
     if (i + 1 == n) {
       if (aEntries[i].mOffset != 1.0f && animationProperty) {
@@ -1326,21 +1326,21 @@ RequiresAdditiveAnimation(const nsTArray
   // StyleAnimationValue since doing that requires a target element bound to
   // a document which we might not always have at the point where we want to
   // perform this check.
   //
   // This is only a temporary measure until we implement additive animation.
   // So as long as this check catches most cases, and we don't do anything
   // horrible in one of the cases we can't detect, it should be sufficient.
 
-  nsCSSPropertyIDSet properties;              // All properties encountered.
-  nsCSSPropertyIDSet propertiesWithFromValue; // Those with a defined 0% value.
-  nsCSSPropertyIDSet propertiesWithToValue;   // Those with a defined 100% value.
+  nsCSSPropertySet properties;              // All properties encountered.
+  nsCSSPropertySet propertiesWithFromValue; // Those with a defined 0% value.
+  nsCSSPropertySet propertiesWithToValue;   // Those with a defined 100% value.
 
-  auto addToPropertySets = [&](nsCSSPropertyID aProperty, double aOffset) {
+  auto addToPropertySets = [&](nsCSSProperty aProperty, double aOffset) {
     properties.AddProperty(aProperty);
     if (aOffset == 0.0) {
       propertiesWithFromValue.AddProperty(aProperty);
     } else if (aOffset == 1.0) {
       propertiesWithToValue.AddProperty(aProperty);
     }
   };
 
@@ -1495,22 +1495,22 @@ PaceRange(const Range<Keyframe>& aKeyfra
  *
  * @param aValues The computed values returned by GetComputedKeyframeValues.
  * @param aPacedProperty The paced property.
  * @return The cumulative distances for the paced property. The length will be
  *   the same as aValues.
  */
 static nsTArray<double>
 GetCumulativeDistances(const nsTArray<ComputedKeyframeValues>& aValues,
-                       nsCSSPropertyID aPacedProperty)
+                       nsCSSProperty aPacedProperty)
 {
   // a) If aPacedProperty is a shorthand property, get its components.
   //    Otherwise, just add the longhand property into the set.
   size_t pacedPropertyCount = 0;
-  nsCSSPropertyIDSet pacedPropertySet;
+  nsCSSPropertySet pacedPropertySet;
   bool isShorthand = nsCSSProps::IsShorthand(aPacedProperty);
   if (isShorthand) {
     CSSPROPS_FOR_SHORTHAND_SUBPROPERTIES(p, aPacedProperty,
                                          CSSEnabledState::eForAllContent) {
       pacedPropertySet.AddProperty(*p);
       ++pacedPropertyCount;
     }
   } else {
@@ -1547,17 +1547,17 @@ GetCumulativeDistances(const nsTArray<Co
       // This is the first paceable keyframe so its cumulative distance is 0.0.
       cumulativeDistances[i] = 0.0;
     } else {
       double dist = 0.0;
       if (isShorthand) {
         // Apply the distance by the square root of the sum of squares of
         // longhand component distances.
         for (size_t propIdx = 0; propIdx < pacedPropertyCount; ++propIdx) {
-          nsCSSPropertyID prop = prevPacedValues[propIdx].mProperty;
+          nsCSSProperty prop = prevPacedValues[propIdx].mProperty;
           MOZ_ASSERT(pacedValues[propIdx].mProperty == prop,
                      "Property mismatch");
 
           double componentDistance = 0.0;
           if (StyleAnimationValue::ComputeDistance(
                 prop,
                 prevPacedValues[propIdx].mValue,
                 pacedValues[propIdx].mValue,
--- a/dom/animation/KeyframeUtils.h
+++ b/dom/animation/KeyframeUtils.h
@@ -93,17 +93,17 @@ public:
    *   any value, e.g. eCSSProperty_UNKNOWN.
    * @param aComputedValues The set of computed keyframe values as returned by
    *   GetComputedKeyframeValues. Only used when |aSpacingMode| is
    *   SpacingMode::paced. In all other cases this parameter is unused and may
    *   be any value including an empty array.
    */
   static void ApplySpacing(nsTArray<Keyframe>& aKeyframes,
                            SpacingMode aSpacingMode,
-                           nsCSSPropertyID aProperty,
+                           nsCSSProperty aProperty,
                            nsTArray<ComputedKeyframeValues>& aComputedValues);
 
   /**
    * Wrapper for ApplySpacing to simplify using distribute spacing.
    *
    * @param aKeyframes The set of keyframes to adjust.
    */
   static void ApplyDistributeSpacing(nsTArray<Keyframe>& aKeyframes);
@@ -132,14 +132,14 @@ public:
 
   /**
    * Check if the property or, for shorthands, one or more of
    * its subproperties, is animatable.
    *
    * @param aProperty The property to check.
    * @return true if |aProperty| is animatable.
    */
-  static bool IsAnimatableProperty(nsCSSPropertyID aProperty);
+  static bool IsAnimatableProperty(nsCSSProperty aProperty);
 };
 
 } // namespace mozilla
 
 #endif // mozilla_KeyframeUtils_h
--- a/dom/base/nsDOMWindowUtils.cpp
+++ b/dom/base/nsDOMWindowUtils.cpp
@@ -2410,17 +2410,17 @@ nsDOMWindowUtils::BeginTabSwitch()
     return NS_ERROR_FAILURE;
 
   mgr->BeginTabSwitch();
 
   return NS_OK;
 }
 
 static bool
-ComputeAnimationValue(nsCSSPropertyID aProperty,
+ComputeAnimationValue(nsCSSProperty aProperty,
                       Element* aElement,
                       const nsAString& aInput,
                       StyleAnimationValue& aOutput)
 {
   nsIDocument* doc = aElement->GetUncomposedDoc();
   nsIPresShell* shell = doc->GetShell();
   if (!shell) {
     return false;
@@ -2670,17 +2670,17 @@ nsDOMWindowUtils::ComputeAnimationDistan
                                            const nsAString& aValue1,
                                            const nsAString& aValue2,
                                            double* aResult)
 {
   nsresult rv;
   nsCOMPtr<nsIContent> content = do_QueryInterface(aElement, &rv);
   NS_ENSURE_SUCCESS(rv, rv);
 
-  nsCSSPropertyID property =
+  nsCSSProperty property =
     nsCSSProps::LookupProperty(aProperty, CSSEnabledState::eIgnoreEnabledState);
   if (property != eCSSProperty_UNKNOWN && nsCSSProps::IsShorthand(property)) {
     property = eCSSProperty_UNKNOWN;
   }
 
   MOZ_ASSERT(property == eCSSProperty_UNKNOWN ||
              !nsCSSProps::IsShorthand(property),
              "should not have shorthand");
--- a/dom/base/nsTreeSanitizer.cpp
+++ b/dom/base/nsTreeSanitizer.cpp
@@ -7,17 +7,17 @@
 #include "nsTreeSanitizer.h"
 
 #include "mozilla/ArrayUtils.h"
 #include "mozilla/CSSStyleSheet.h"
 #include "mozilla/css/Declaration.h"
 #include "mozilla/css/StyleRule.h"
 #include "mozilla/css/Rule.h"
 #include "nsCSSParser.h"
-#include "nsCSSPropertyID.h"
+#include "nsCSSProperty.h"
 #include "nsUnicharInputStream.h"
 #include "nsIDOMCSSRule.h"
 #include "nsAttrName.h"
 #include "nsIScriptSecurityManager.h"
 #include "nsNetUtil.h"
 #include "nsComponentManagerUtils.h"
 #include "nsNullPrincipal.h"
 #include "nsContentUtils.h"
--- a/dom/canvas/CanvasRenderingContext2D.cpp
+++ b/dom/canvas/CanvasRenderingContext2D.cpp
@@ -2398,18 +2398,18 @@ CanvasRenderingContext2D::SetShadowColor
 }
 
 //
 // filters
 //
 
 static already_AddRefed<Declaration>
 CreateDeclaration(nsINode* aNode,
-  const nsCSSPropertyID aProp1, const nsAString& aValue1, bool* aChanged1,
-  const nsCSSPropertyID aProp2, const nsAString& aValue2, bool* aChanged2)
+  const nsCSSProperty aProp1, const nsAString& aValue1, bool* aChanged1,
+  const nsCSSProperty aProp2, const nsAString& aValue2, bool* aChanged2)
 {
   nsIPrincipal* principal = aNode->NodePrincipal();
   nsIDocument* document = aNode->OwnerDoc();
 
   nsIURI* docURL = document->GetDocumentURI();
   nsIURI* baseURL = document->GetDocBaseURI();
 
   // Pass the CSS Loader object to the parser, to allow parser error reports
@@ -2484,17 +2484,17 @@ GetFontParentStyleContext(Element* aElem
   if (!result) {
     aError.Throw(NS_ERROR_FAILURE);
     return nullptr;
   }
   return result.forget();
 }
 
 static bool
-PropertyIsInheritOrInitial(Declaration* aDeclaration, const nsCSSPropertyID aProperty)
+PropertyIsInheritOrInitial(Declaration* aDeclaration, const nsCSSProperty aProperty)
 {
   // We know the declaration is not !important, so we can use
   // GetNormalBlock().
   const nsCSSValue* filterVal =
     aDeclaration->GetNormalBlock()->ValueFor(aProperty);
   return (!filterVal || (filterVal->GetUnit() == eCSSUnit_Unset ||
                          filterVal->GetUnit() == eCSSUnit_Inherit ||
                          filterVal->GetUnit() == eCSSUnit_Initial));
--- a/dom/html/HTMLHRElement.cpp
+++ b/dom/html/HTMLHRElement.cpp
@@ -201,17 +201,17 @@ HTMLHRElement::MapAttributesIntoRule(con
         borderLeftStyle->SetIntValue(NS_STYLE_BORDER_STYLE_SOLID,
                                      eCSSUnit_Enumerated);
       }
 
       // If it would be noticeable, set the border radius to
       // 10000px on all corners; this triggers the clamping to make
       // circular ends.  This assumes the <hr> isn't larger than
       // that in *both* dimensions.
-      for (const nsCSSPropertyID* props =
+      for (const nsCSSProperty* props =
             nsCSSProps::SubpropertyEntryFor(eCSSProperty_border_radius);
            *props != eCSSProperty_UNKNOWN; ++props) {
         nsCSSValue* dimen = aData->ValueFor(*props);
         if (dimen->GetUnit() == eCSSUnit_Null) {
           dimen->SetFloatValue(10000.0f, eCSSUnit_Pixel);
         }
       }
     }
--- a/dom/smil/nsSMILAnimationController.cpp
+++ b/dom/smil/nsSMILAnimationController.cpp
@@ -688,17 +688,17 @@ nsSMILAnimationController::GetTargetIden
   if (attributeType == eSMILTargetAttrType_auto) {
     if (attributeNamespaceID == kNameSpaceID_None) {
       // width/height are special as they may be attributes or for
       // outer-<svg> elements, mapped into style.
       if (attributeName == nsGkAtoms::width ||
           attributeName == nsGkAtoms::height) {
         isCSS = targetElem->GetNameSpaceID() != kNameSpaceID_SVG;
       } else {
-        nsCSSPropertyID prop =
+        nsCSSProperty prop =
           nsCSSProps::LookupProperty(nsDependentAtomString(attributeName),
                                      CSSEnabledState::eForAllContent);
         isCSS = nsSMILCSSProperty::IsPropertyAnimatable(prop);
       }
     }
   } else {
     isCSS = (attributeType == eSMILTargetAttrType_CSS);
   }
--- a/dom/smil/nsSMILCSSProperty.cpp
+++ b/dom/smil/nsSMILCSSProperty.cpp
@@ -17,17 +17,17 @@
 #include "nsIDOMElement.h"
 #include "nsIDocument.h"
 
 using namespace mozilla::dom;
 
 // Helper function
 static bool
 GetCSSComputedValue(Element* aElem,
-                    nsCSSPropertyID aPropID,
+                    nsCSSProperty aPropID,
                     nsAString& aResult)
 {
   MOZ_ASSERT(!nsCSSProps::IsShorthand(aPropID),
              "Can't look up computed value of shorthand property");
   MOZ_ASSERT(nsSMILCSSProperty::IsPropertyAnimatable(aPropID),
              "Shouldn't get here for non-animatable properties");
 
   nsIDocument* doc = aElem->GetUncomposedDoc();
@@ -47,17 +47,17 @@ GetCSSComputedValue(Element* aElem,
   RefPtr<nsComputedDOMStyle> computedStyle =
     NS_NewComputedDOMStyle(aElem, EmptyString(), shell);
 
   computedStyle->GetPropertyValue(aPropID, aResult);
   return true;
 }
 
 // Class Methods
-nsSMILCSSProperty::nsSMILCSSProperty(nsCSSPropertyID aPropID,
+nsSMILCSSProperty::nsSMILCSSProperty(nsCSSProperty aPropID,
                                      Element* aElement)
   : mPropID(aPropID), mElement(aElement)
 {
   MOZ_ASSERT(IsPropertyAnimatable(mPropID),
              "Creating a nsSMILCSSProperty for a property "
              "that's not supported for animation");
 }
 
@@ -181,17 +181,17 @@ nsSMILCSSProperty::ClearAnimValue()
   if (overrideDecl) {
     overrideDecl->SetPropertyValue(mPropID, EmptyString());
   }
 }
 
 // Based on http://www.w3.org/TR/SVG/propidx.html
 // static
 bool
-nsSMILCSSProperty::IsPropertyAnimatable(nsCSSPropertyID aPropID)
+nsSMILCSSProperty::IsPropertyAnimatable(nsCSSProperty aPropID)
 {
   // NOTE: Right now, Gecko doesn't recognize the following properties from
   // the SVG Property Index:
   //   alignment-baseline
   //   baseline-shift
   //   color-profile
   //   color-rendering
   //   glyph-orientation-horizontal
--- a/dom/smil/nsSMILCSSProperty.h
+++ b/dom/smil/nsSMILCSSProperty.h
@@ -7,17 +7,17 @@
 /* representation of a SMIL-animatable CSS property on an element */
 
 #ifndef NS_SMILCSSPROPERTY_H_
 #define NS_SMILCSSPROPERTY_H_
 
 #include "mozilla/Attributes.h"
 #include "nsISMILAttr.h"
 #include "nsIAtom.h"
-#include "nsCSSPropertyID.h"
+#include "nsCSSProperty.h"
 #include "nsCSSValue.h"
 
 namespace mozilla {
 namespace dom {
 class Element;
 } // namespace dom
 } // namespace mozilla
 
@@ -29,17 +29,17 @@ class Element;
 class nsSMILCSSProperty : public nsISMILAttr
 {
 public:
   /**
    * Constructs a new nsSMILCSSProperty.
    * @param  aPropID   The CSS property we're interested in animating.
    * @param  aElement  The element whose CSS property is being animated.
    */
-  nsSMILCSSProperty(nsCSSPropertyID aPropID, mozilla::dom::Element* aElement);
+  nsSMILCSSProperty(nsCSSProperty aPropID, mozilla::dom::Element* aElement);
 
   // nsISMILAttr methods
   virtual nsresult ValueFromString(const nsAString& aStr,
                                    const mozilla::dom::SVGAnimationElement* aSrcElement,
                                    nsSMILValue& aValue,
                                    bool& aPreventCachingOfSandwich) const override;
   virtual nsSMILValue GetBaseValue() const override;
   virtual nsresult    SetAnimValue(const nsSMILValue& aValue) override;
@@ -48,20 +48,20 @@ public:
   /**
    * Utility method - returns true if the given property is supported for
    * SMIL animation.
    *
    * @param   aProperty  The property to check for animation support.
    * @return  true if the given property is supported for SMIL animation, or
    *          false otherwise
    */
-  static bool IsPropertyAnimatable(nsCSSPropertyID aPropID);
+  static bool IsPropertyAnimatable(nsCSSProperty aPropID);
 
 protected:
-  nsCSSPropertyID mPropID;
+  nsCSSProperty mPropID;
   // Using non-refcounted pointer for mElement -- we know mElement will stay
   // alive for my lifetime because a nsISMILAttr (like me) only lives as long
   // as the Compositing step, and DOM elements don't get a chance to die during
   // that time.
   mozilla::dom::Element*   mElement;
 };
 
 #endif // NS_SMILCSSPROPERTY_H_
--- a/dom/smil/nsSMILCSSValueType.cpp
+++ b/dom/smil/nsSMILCSSValueType.cpp
@@ -20,20 +20,20 @@
 #include "nsIDocument.h"
 
 using namespace mozilla::dom;
 using mozilla::StyleAnimationValue;
 
 /*static*/ nsSMILCSSValueType nsSMILCSSValueType::sSingleton;
 
 struct ValueWrapper {
-  ValueWrapper(nsCSSPropertyID aPropID, const StyleAnimationValue& aValue) :
+  ValueWrapper(nsCSSProperty aPropID, const StyleAnimationValue& aValue) :
     mPropID(aPropID), mCSSValue(aValue) {}
 
-  nsCSSPropertyID mPropID;
+  nsCSSProperty mPropID;
   StyleAnimationValue mCSSValue;
 };
 
 // Helper Methods
 // --------------
 static const StyleAnimationValue*
 GetZeroValueForUnit(StyleAnimationValue::Unit aUnit)
 {
@@ -218,17 +218,17 @@ nsSMILCSSValueType::Add(nsSMILValue& aDe
              "Trying to add invalid types");
   MOZ_ASSERT(aValueToAdd.mType == this, "Unexpected source type");
 
   ValueWrapper* destWrapper = ExtractValueWrapper(aDest);
   const ValueWrapper* valueToAddWrapper = ExtractValueWrapper(aValueToAdd);
   MOZ_ASSERT(destWrapper || valueToAddWrapper,
              "need at least one fully-initialized value");
 
-  nsCSSPropertyID property = (valueToAddWrapper ? valueToAddWrapper->mPropID :
+  nsCSSProperty property = (valueToAddWrapper ? valueToAddWrapper->mPropID :
                             destWrapper->mPropID);
   // Special case: font-size-adjust and stroke-dasharray are explicitly
   // non-additive (even though StyleAnimationValue *could* support adding them)
   if (property == eCSSProperty_font_size_adjust ||
       property == eCSSProperty_stroke_dasharray) {
     return NS_ERROR_FAILURE;
   }
 
@@ -330,17 +330,17 @@ GetPresContextForElement(Element* aElem)
     return nullptr;
   }
   nsIPresShell* shell = doc->GetShell();
   return shell ? shell->GetPresContext() : nullptr;
 }
 
 // Helper function to parse a string into a StyleAnimationValue
 static bool
-ValueFromStringHelper(nsCSSPropertyID aPropID,
+ValueFromStringHelper(nsCSSProperty aPropID,
                       Element* aTargetElement,
                       nsPresContext* aPresContext,
                       const nsAString& aString,
                       StyleAnimationValue& aStyleAnimValue,
                       bool* aIsContextSensitive)
 {
   // If value is negative, we'll strip off the "-" so the CSS parser won't
   // barf, and then manually make the parsed value negative.
@@ -382,17 +382,17 @@ ValueFromStringHelper(nsCSSPropertyID aP
     aStyleAnimValue.SetCoordValue(aStyleAnimValue.GetCoordValue() /
                                   aPresContext->TextZoom());
   }
   return true;
 }
 
 // static
 void
-nsSMILCSSValueType::ValueFromString(nsCSSPropertyID aPropID,
+nsSMILCSSValueType::ValueFromString(nsCSSProperty aPropID,
                                     Element* aTargetElement,
                                     const nsAString& aString,
                                     nsSMILValue& aValue,
                                     bool* aIsContextSensitive)
 {
   MOZ_ASSERT(aValue.IsNull(), "Outparam should be null-typed");
   nsPresContext* presContext = GetPresContextForElement(aTargetElement);
   if (!presContext) {
@@ -425,17 +425,17 @@ nsSMILCSSValueType::ValueToString(const 
              "Unexpected SMIL value type");
   const ValueWrapper* wrapper = ExtractValueWrapper(aValue);
   return !wrapper ||
     StyleAnimationValue::UncomputeValue(wrapper->mPropID,
                                         wrapper->mCSSValue, aString);
 }
 
 // static
-nsCSSPropertyID
+nsCSSProperty
 nsSMILCSSValueType::PropertyFromValue(const nsSMILValue& aValue)
 {
   if (aValue.mType != &nsSMILCSSValueType::sSingleton) {
     return eCSSProperty_UNKNOWN;
   }
 
   const ValueWrapper* wrapper = ExtractValueWrapper(aValue);
   if (!wrapper) {
--- a/dom/smil/nsSMILCSSValueType.h
+++ b/dom/smil/nsSMILCSSValueType.h
@@ -5,17 +5,17 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 /* representation of a value for a SMIL-animated CSS property */
 
 #ifndef NS_SMILCSSVALUETYPE_H_
 #define NS_SMILCSSVALUETYPE_H_
 
 #include "nsISMILType.h"
-#include "nsCSSPropertyID.h"
+#include "nsCSSProperty.h"
 #include "mozilla/Attributes.h"
 
 class nsAString;
 
 namespace mozilla {
 namespace dom {
 class Element;
 } // namespace dom
@@ -73,17 +73,17 @@ public:
    *                                  a different |aValue| depending on other
    *                                  CSS properties on |aTargetElement|
    *                                  or its ancestors (e.g. 'inherit).
    *                                  false otherwise. May be nullptr.
    *                                  Not set if the method fails.
    * @pre  aValue.IsNull()
    * @post aValue.IsNull() || aValue.mType == nsSMILCSSValueType::sSingleton
    */
-  static void ValueFromString(nsCSSPropertyID aPropID,
+  static void ValueFromString(nsCSSProperty aPropID,
                               Element* aTargetElement,
                               const nsAString& aString,
                               nsSMILValue& aValue,
                               bool* aIsContextSensitive);
 
   /**
    * Creates a string representation of the given nsSMILValue.
    *
@@ -97,20 +97,20 @@ public:
    * @return               true on success, false on failure.
    */
   static bool ValueToString(const nsSMILValue& aValue, nsAString& aString);
 
   /**
    * Return the CSS property animated by the specified value.
    *
    * @param   aValue   The nsSMILValue to examine.
-   * @return           The nsCSSPropertyID enum value of the property animated
+   * @return           The nsCSSProperty enum value of the property animated
    *                   by |aValue|, or eCSSProperty_UNKNOWN if the type of
    *                   |aValue| is not nsSMILCSSValueType.
    */
-  static nsCSSPropertyID PropertyFromValue(const nsSMILValue& aValue);
+  static nsCSSProperty PropertyFromValue(const nsSMILValue& aValue);
 
 private:
   // Private constructor: prevent instances beyond my singleton.
   constexpr nsSMILCSSValueType() {}
 };
 
 #endif // NS_SMILCSSVALUETYPE_H_
--- a/dom/smil/nsSMILCompositor.cpp
+++ b/dom/smil/nsSMILCompositor.cpp
@@ -122,17 +122,17 @@ nsSMILCompositor::ClearAnimationEffects(
 }
 
 // Protected Helper Functions
 // --------------------------
 nsISMILAttr*
 nsSMILCompositor::CreateSMILAttr()
 {
   if (mKey.mIsCSS) {
-    nsCSSPropertyID propId =
+    nsCSSProperty propId =
       nsCSSProps::LookupProperty(nsDependentAtomString(mKey.mAttributeName),
                                  CSSEnabledState::eForAllContent);
     if (nsSMILCSSProperty::IsPropertyAnimatable(propId)) {
       return new nsSMILCSSProperty(propId, mKey.mElement.get());
     }
   } else {
     return mKey.mElement->GetAnimatedAttr(mKey.mAttributeNamespaceID,
                                           mKey.mAttributeName);
--- a/dom/smil/nsSMILMappedAttribute.h
+++ b/dom/smil/nsSMILMappedAttribute.h
@@ -31,17 +31,17 @@ class nsSMILMappedAttribute : public nsS
 public:
   /**
    * Constructs a new nsSMILMappedAttribute.
    *
    * @param  aPropID   The CSS property for the mapped attribute we're
    *                   interested in animating.
    * @param  aElement  The element whose attribute is being animated.
    */
-  nsSMILMappedAttribute(nsCSSPropertyID aPropID, mozilla::dom::Element* aElement) :
+  nsSMILMappedAttribute(nsCSSProperty aPropID, mozilla::dom::Element* aElement) :
     nsSMILCSSProperty(aPropID, aElement) {}
 
   // nsISMILAttr methods
   virtual nsresult ValueFromString(const nsAString& aStr,
                                    const mozilla::dom::SVGAnimationElement* aSrcElement,
                                    nsSMILValue& aValue,
                                    bool& aPreventCachingOfSandwich) const override;
   virtual nsSMILValue GetBaseValue() const override;
--- a/dom/svg/nsSVGElement.cpp
+++ b/dom/svg/nsSVGElement.cpp
@@ -1194,18 +1194,18 @@ void
 MappedAttrParser::ParseMappedAttrValue(nsIAtom* aMappedAttrName,
                                        const nsAString& aMappedAttrValue)
 {
   if (!mDecl) {
     mDecl = new css::Declaration();
     mDecl->InitializeEmpty();
   }
 
-  // Get the nsCSSPropertyID ID for our mapped attribute.
-  nsCSSPropertyID propertyID =
+  // Get the nsCSSProperty ID for our mapped attribute.
+  nsCSSProperty propertyID =
     nsCSSProps::LookupProperty(nsDependentAtomString(aMappedAttrName),
                                CSSEnabledState::eForAllContent);
   if (propertyID != eCSSProperty_UNKNOWN) {
     bool changed = false; // outparam for ParseProperty.
     mParser.ParseProperty(propertyID, aMappedAttrValue, mDocURI, mBaseURI,
                           mElement->NodePrincipal(), mDecl, &changed, false, true);
     if (changed) {
       // The normal reporting of use counters by the nsCSSParser won't happen
@@ -2553,17 +2553,17 @@ nsSVGElement::GetAnimatedAttr(int32_t aN
   if (aNamespaceID == kNameSpaceID_None) {
     // We check mapped-into-style attributes first so that animations
     // targeting width/height on outer-<svg> don't appear to be ignored
     // because we returned a nsISMILAttr for the corresponding
     // SVGAnimatedLength.
 
     // Mapped attributes:
     if (IsAttributeMapped(aName)) {
-      nsCSSPropertyID prop =
+      nsCSSProperty prop =
         nsCSSProps::LookupProperty(nsDependentAtomString(aName),
                                    CSSEnabledState::eForAllContent);
       // Check IsPropertyAnimatable to avoid attributes that...
       //  - map to explicitly unanimatable properties (e.g. 'direction')
       //  - map to unsupported attributes (e.g. 'glyph-orientation-horizontal')
       if (nsSMILCSSProperty::IsPropertyAnimatable(prop)) {
         return new nsSMILMappedAttribute(prop, this);
       }
--- a/editor/libeditor/CSSEditUtils.cpp
+++ b/editor/libeditor/CSSEditUtils.cpp
@@ -543,17 +543,17 @@ CSSEditUtils::GetCSSInlinePropertyBase(n
     return NS_OK;
   }
 
   MOZ_ASSERT(aStyleType == eSpecified);
   RefPtr<css::Declaration> decl = element->GetInlineStyleDeclaration();
   if (!decl) {
     return NS_OK;
   }
-  nsCSSPropertyID prop =
+  nsCSSProperty prop =
     nsCSSProps::LookupProperty(nsDependentAtomString(aProperty),
                                CSSEnabledState::eForAllContent);
   MOZ_ASSERT(prop != eCSSProperty_UNKNOWN);
   decl->GetValue(prop, aValue);
 
   return NS_OK;
 }
 
--- a/gfx/layers/Layers.h
+++ b/gfx/layers/Layers.h
@@ -31,17 +31,17 @@
 #include "mozilla/gfx/Point.h"          // for IntSize
 #include "mozilla/gfx/TiledRegion.h"    // for TiledIntRegion
 #include "mozilla/gfx/Types.h"          // for SurfaceFormat
 #include "mozilla/gfx/UserData.h"       // for UserData, etc
 #include "mozilla/layers/LayersTypes.h"
 #include "mozilla/mozalloc.h"           // for operator delete, etc
 #include "nsAutoPtr.h"                  // for nsAutoPtr, nsRefPtr, etc
 #include "nsCOMPtr.h"                   // for already_AddRefed
-#include "nsCSSPropertyID.h"              // for nsCSSPropertyID
+#include "nsCSSProperty.h"              // for nsCSSProperty
 #include "nsDebug.h"                    // for NS_ASSERTION
 #include "nsISupportsImpl.h"            // for Layer::Release, etc
 #include "nsRect.h"                     // for mozilla::gfx::IntRect
 #include "nsRegion.h"                   // for nsIntRegion
 #include "nsString.h"                   // for nsCString
 #include "nsTArray.h"                   // for nsTArray
 #include "nsTArrayForwardDeclare.h"     // for InfallibleTArray
 #include "nscore.h"                     // for nsACString, nsAString
--- a/gfx/layers/ipc/LayersMessages.ipdlh
+++ b/gfx/layers/ipc/LayersMessages.ipdlh
@@ -23,17 +23,17 @@ using struct mozilla::gfx::Point3D from 
 using mozilla::gfx::IntPoint from "mozilla/gfx/Point.h";
 using class mozilla::gfx::Matrix4x4 from "mozilla/gfx/Matrix.h";
 using nscoord from "nsCoord.h";
 using struct nsRect from "nsRect.h";
 using struct nsPoint from "nsPoint.h";
 using class mozilla::TimeDuration from "mozilla/TimeStamp.h";
 using class mozilla::TimeStamp from "mozilla/TimeStamp.h";
 using mozilla::ScreenRotation from "mozilla/WidgetUtils.h";
-using nsCSSPropertyID from "nsCSSPropertyID.h";
+using nsCSSProperty from "nsCSSProperty.h";
 using mozilla::dom::ScreenOrientationInternal from "mozilla/dom/ScreenOrientation.h";
 using struct mozilla::layers::TextureInfo from "mozilla/layers/CompositorTypes.h";
 using mozilla::LayerMargin from "Units.h";
 using mozilla::LayerPoint from "Units.h";
 using mozilla::LayerRect from "Units.h";
 using mozilla::LayerIntRegion from "Units.h";
 using mozilla::ParentLayerIntRect from "Units.h";
 using mozilla::LayoutDeviceIntRect from "Units.h";
@@ -194,17 +194,17 @@ struct Animation {
   AnimationSegment[] segments;
   // Number of times to repeat the animation, including positive infinity.
   // Values <= 0 mean the animation will not play (although events are still
   // dispatched on the main thread).
   float iterations;
   float iterationStart;
   // This uses the NS_STYLE_ANIMATION_DIRECTION_* constants.
   int32_t direction;
-  nsCSSPropertyID property;
+  nsCSSProperty property;
   AnimationData data;
   float playbackRate;
   // This is used in the transformed progress calculation.
   TimingFunction easingFunction;
 };
 
 // Change a layer's attributes
 struct CommonLayerAttributes {
--- a/ipc/glue/IPCMessageUtils.h
+++ b/ipc/glue/IPCMessageUtils.h
@@ -29,17 +29,17 @@
 #include "nsExceptionHandler.h"
 #endif
 #include "nsID.h"
 #include "nsIWidget.h"
 #include "nsMemory.h"
 #include "nsString.h"
 #include "nsTArray.h"
 #include "js/StructuredClone.h"
-#include "nsCSSPropertyID.h"
+#include "nsCSSProperty.h"
 
 #ifdef _MSC_VER
 #pragma warning( disable : 4800 )
 #endif
 
 #if !defined(OS_POSIX)
 // This condition must be kept in sync with the one in
 // ipc_message_utils.h, but this dummy definition of
@@ -535,18 +535,18 @@ struct ParamTraits<float>
 
   static void Log(const paramType& aParam, std::wstring* aLog)
   {
     aLog->append(StringPrintf(L"%g", aParam));
   }
 };
 
 template <>
-struct ParamTraits<nsCSSPropertyID>
-  : public ContiguousEnumSerializer<nsCSSPropertyID,
+struct ParamTraits<nsCSSProperty>
+  : public ContiguousEnumSerializer<nsCSSProperty,
                                     eCSSProperty_UNKNOWN,
                                     eCSSProperty_COUNT>
 {};
 
 template<>
 struct ParamTraits<mozilla::void_t>
 {
   typedef mozilla::void_t paramType;
--- a/layout/base/ActiveLayerTracker.cpp
+++ b/layout/base/ActiveLayerTracker.cpp
@@ -61,22 +61,22 @@ public:
     : mFrame(aFrame)
     , mContent(nullptr)
     , mContentActive(false)
   {
     PodArrayZero(mRestyleCounts);
   }
   ~LayerActivity();
   nsExpirationState* GetExpirationState() { return &mState; }
-  uint8_t& RestyleCountForProperty(nsCSSPropertyID aProperty)
+  uint8_t& RestyleCountForProperty(nsCSSProperty aProperty)
   {
     return mRestyleCounts[GetActivityIndexForProperty(aProperty)];
   }
 
-  static ActivityIndex GetActivityIndexForProperty(nsCSSPropertyID aProperty)
+  static ActivityIndex GetActivityIndexForProperty(nsCSSProperty aProperty)
   {
     switch (aProperty) {
     case eCSSProperty_opacity: return ACTIVITY_OPACITY;
     case eCSSProperty_transform: return ACTIVITY_TRANSFORM;
     case eCSSProperty_left: return ACTIVITY_LEFT;
     case eCSSProperty_top: return ACTIVITY_TOP;
     case eCSSProperty_right: return ACTIVITY_RIGHT;
     case eCSSProperty_bottom: return ACTIVITY_BOTTOM;
@@ -287,17 +287,17 @@ IncrementScaleRestyleCountIfNeeded(nsIFr
     return;  // Nothing changed.
   }
 
   aActivity->mPreviousTransformScale = Some(scale);
   IncrementMutationCount(&aActivity->mRestyleCounts[LayerActivity::ACTIVITY_SCALE]);
 }
 
 /* static */ void
-ActiveLayerTracker::NotifyRestyle(nsIFrame* aFrame, nsCSSPropertyID aProperty)
+ActiveLayerTracker::NotifyRestyle(nsIFrame* aFrame, nsCSSProperty aProperty)
 {
   LayerActivity* layerActivity = GetLayerActivityForUpdate(aFrame);
   uint8_t& mutationCount = layerActivity->RestyleCountForProperty(aProperty);
   IncrementMutationCount(&mutationCount);
 
   if (aProperty == eCSSProperty_transform) {
     IncrementScaleRestyleCountIfNeeded(aFrame, layerActivity);
   }
@@ -310,34 +310,34 @@ ActiveLayerTracker::NotifyOffsetRestyle(
   IncrementMutationCount(&layerActivity->mRestyleCounts[LayerActivity::ACTIVITY_LEFT]);
   IncrementMutationCount(&layerActivity->mRestyleCounts[LayerActivity::ACTIVITY_TOP]);
   IncrementMutationCount(&layerActivity->mRestyleCounts[LayerActivity::ACTIVITY_RIGHT]);
   IncrementMutationCount(&layerActivity->mRestyleCounts[LayerActivity::ACTIVITY_BOTTOM]);
 }
 
 /* static */ void
 ActiveLayerTracker::NotifyAnimated(nsIFrame* aFrame,
-                                   nsCSSPropertyID aProperty,
+                                   nsCSSProperty aProperty,
                                    const nsAString& aNewValue,
                                    nsDOMCSSDeclaration* aDOMCSSDecl)
 {
   LayerActivity* layerActivity = GetLayerActivityForUpdate(aFrame);
   uint8_t& mutationCount = layerActivity->RestyleCountForProperty(aProperty);
   if (mutationCount != 0xFF) {
     nsAutoString oldValue;
     aDOMCSSDecl->GetPropertyValue(aProperty, oldValue);
     if (aNewValue != oldValue) {
       // We know this is animated, so just hack the mutation count.
       mutationCount = 0xFF;
     }
   }
 }
 
 /* static */ void
-ActiveLayerTracker::NotifyAnimatedFromScrollHandler(nsIFrame* aFrame, nsCSSPropertyID aProperty,
+ActiveLayerTracker::NotifyAnimatedFromScrollHandler(nsIFrame* aFrame, nsCSSProperty aProperty,
                                                     nsIFrame* aScrollFrame)
 {
   if (aFrame->PresContext() != aScrollFrame->PresContext()) {
     // Don't allow cross-document dependencies.
     return;
   }
   LayerActivity* layerActivity = GetLayerActivityForUpdate(aFrame);
   LayerActivity::ActivityIndex activityIndex = LayerActivity::GetActivityIndexForProperty(aProperty);
@@ -361,32 +361,32 @@ IsPresContextInScriptAnimationCallback(n
   // Treat timeouts/setintervals as scripted animation callbacks for our
   // purposes.
   nsPIDOMWindowInner* win = aPresContext->Document()->GetInnerWindow();
   return win && win->IsRunningTimeout();
 }
 
 /* static */ void
 ActiveLayerTracker::NotifyInlineStyleRuleModified(nsIFrame* aFrame,
-                                                  nsCSSPropertyID aProperty,
+                                                  nsCSSProperty aProperty,
                                                   const nsAString& aNewValue,
                                                   nsDOMCSSDeclaration* aDOMCSSDecl)
 {
   if (IsPresContextInScriptAnimationCallback(aFrame->PresContext())) {
     NotifyAnimated(aFrame, aProperty, aNewValue, aDOMCSSDecl);
   }
   if (gLayerActivityTracker &&
       gLayerActivityTracker->mCurrentScrollHandlerFrame.IsAlive()) {
     NotifyAnimatedFromScrollHandler(aFrame, aProperty,
       gLayerActivityTracker->mCurrentScrollHandlerFrame.GetFrame());
   }
 }
 
 /* static */ bool
-ActiveLayerTracker::IsStyleMaybeAnimated(nsIFrame* aFrame, nsCSSPropertyID aProperty)
+ActiveLayerTracker::IsStyleMaybeAnimated(nsIFrame* aFrame, nsCSSProperty aProperty)
 {
   return IsStyleAnimated(nullptr, aFrame, aProperty);
 }
 
 /* static */ bool
 ActiveLayerTracker::IsBackgroundPositionAnimated(nsDisplayListBuilder* aBuilder,
                                                  nsIFrame* aFrame)
 {
@@ -414,17 +414,17 @@ CheckScrollInducedActivity(LayerActivity
   // the layer activity so that it can expire.
   aLayerActivity->mAnimatingScrollHandlerFrame = nullptr;
   aLayerActivity->mScrollHandlerInducedActivity.clear();
   return false;
 }
 
 /* static */ bool
 ActiveLayerTracker::IsStyleAnimated(nsDisplayListBuilder* aBuilder,
-                                    nsIFrame* aFrame, nsCSSPropertyID aProperty)
+                                    nsIFrame* aFrame, nsCSSProperty aProperty)
 {
   // TODO: Add some abuse restrictions
   if ((aFrame->StyleDisplay()->mWillChangeBitField & NS_STYLE_WILL_CHANGE_TRANSFORM) &&
       aProperty == eCSSProperty_transform &&
       (!aBuilder || aBuilder->IsInWillChangeBudget(aFrame, aFrame->GetSize()))) {
     return true;
   }
   if ((aFrame->StyleDisplay()->mWillChangeBitField & NS_STYLE_WILL_CHANGE_OPACITY) &&
--- a/layout/base/ActiveLayerTracker.h
+++ b/layout/base/ActiveLayerTracker.h
@@ -1,16 +1,16 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef ACTIVELAYERTRACKER_H_
 #define ACTIVELAYERTRACKER_H_
 
-#include "nsCSSPropertyID.h"
+#include "nsCSSProperty.h"
 
 class nsIFrame;
 class nsIContent;
 class nsDisplayListBuilder;
 class nsDOMCSSDeclaration;
 
 namespace mozilla {
 
@@ -33,60 +33,60 @@ public:
    */
 
   /**
    * Notify aFrame's style property as having changed due to a restyle,
    * and therefore possibly wanting an active layer to render that style.
    * Any such marking will time out after a short period.
    * @param aProperty the property that has changed
    */
-  static void NotifyRestyle(nsIFrame* aFrame, nsCSSPropertyID aProperty);
+  static void NotifyRestyle(nsIFrame* aFrame, nsCSSProperty aProperty);
   /**
    * Notify aFrame's left/top/right/bottom properties as having (maybe)
    * changed due to a restyle, and therefore possibly wanting an active layer
    * to render that style. Any such marking will time out after a short period.
    */
   static void NotifyOffsetRestyle(nsIFrame* aFrame);
   /**
    * Mark aFrame as being known to have an animation of aProperty.
    * Any such marking will time out after a short period.
    * aNewValue and aDOMCSSDecl are used to determine whether the property's
    * value has changed.
    */
-  static void NotifyAnimated(nsIFrame* aFrame, nsCSSPropertyID aProperty,
+  static void NotifyAnimated(nsIFrame* aFrame, nsCSSProperty aProperty,
                              const nsAString& aNewValue,
                              nsDOMCSSDeclaration* aDOMCSSDecl);
   /**
    * Notify aFrame as being known to have an animation of aProperty through an
    * inline style modification during aScrollFrame's scroll event handler.
    */
-  static void NotifyAnimatedFromScrollHandler(nsIFrame* aFrame, nsCSSPropertyID aProperty,
+  static void NotifyAnimatedFromScrollHandler(nsIFrame* aFrame, nsCSSProperty aProperty,
                                               nsIFrame* aScrollFrame);
   /**
    * Notify that a property in the inline style rule of aFrame's element
    * has been modified.
    * This notification is incomplete --- not all modifications to inline
    * style will trigger this.
    * aNewValue and aDOMCSSDecl are used to determine whether the property's
    * value has changed.
    */
-  static void NotifyInlineStyleRuleModified(nsIFrame* aFrame, nsCSSPropertyID aProperty,
+  static void NotifyInlineStyleRuleModified(nsIFrame* aFrame, nsCSSProperty aProperty,
                                             const nsAString& aNewValue,
                                             nsDOMCSSDeclaration* aDOMCSSDecl);
   /**
    * Return true if aFrame's aProperty style should be considered as being animated
    * for pre-rendering.
    */
-  static bool IsStyleMaybeAnimated(nsIFrame* aFrame, nsCSSPropertyID aProperty);
+  static bool IsStyleMaybeAnimated(nsIFrame* aFrame, nsCSSProperty aProperty);
   /**
    * Return true if aFrame's aProperty style should be considered as being animated
    * for constructing active layers.
    */
   static bool IsStyleAnimated(nsDisplayListBuilder* aBuilder, nsIFrame* aFrame,
-                              nsCSSPropertyID aProperty);
+                              nsCSSProperty aProperty);
   /**
    * Return true if any of aFrame's offset property styles should be considered
    * as being animated for constructing active layers.
    */
   static bool IsOffsetOrMarginStyleAnimated(nsIFrame* aFrame);
   /**
    * Return true if aFrame's background-position-x or background-position-y
    * property is animated.
--- a/layout/base/FrameLayerBuilder.cpp
+++ b/layout/base/FrameLayerBuilder.cpp
@@ -278,17 +278,17 @@ void
 FrameLayerBuilder::DisplayItemData::ClearAnimationCompositorState()
 {
   if (mDisplayItemKey != nsDisplayItem::TYPE_TRANSFORM &&
       mDisplayItemKey != nsDisplayItem::TYPE_OPACITY) {
     return;
   }
 
   for (nsIFrame* frame : mFrameList) {
-    nsCSSPropertyID prop = mDisplayItemKey == nsDisplayItem::TYPE_TRANSFORM ?
+    nsCSSProperty prop = mDisplayItemKey == nsDisplayItem::TYPE_TRANSFORM ?
       eCSSProperty_transform : eCSSProperty_opacity;
     EffectCompositor::ClearIsRunningOnCompositor(frame, prop);
   }
 }
 
 const nsTArray<nsIFrame*>&
 FrameLayerBuilder::DisplayItemData::GetFrameListChanges()
 {
--- a/layout/base/nsDisplayList.cpp
+++ b/layout/base/nsDisplayList.cpp
@@ -453,17 +453,17 @@ AddAnimationForProperty(nsIFrame* aFrame
 
     animSegment->startPortion() = segment.mFromKey;
     animSegment->endPortion() = segment.mToKey;
     animSegment->sampleFn() = ToTimingFunction(segment.mTimingFunction);
   }
 }
 
 static void
-AddAnimationsForProperty(nsIFrame* aFrame, nsCSSPropertyID aProperty,
+AddAnimationsForProperty(nsIFrame* aFrame, nsCSSProperty aProperty,
                          nsTArray<RefPtr<dom::Animation>>& aAnimations,
                          Layer* aLayer, AnimationData& aData,
                          bool aPending)
 {
   MOZ_ASSERT(nsCSSProps::PropHasFlags(aProperty,
                                       CSS_PROPERTY_CAN_ANIMATE_ON_COMPOSITOR),
              "inconsistent property flags");
 
@@ -594,17 +594,17 @@ GenerateAndPushTextMask(nsIFrame* aFrame
   return true;
 }
 
 /* static */ void
 nsDisplayListBuilder::AddAnimationsAndTransitionsToLayer(Layer* aLayer,
                                                          nsDisplayListBuilder* aBuilder,
                                                          nsDisplayItem* aItem,
                                                          nsIFrame* aFrame,
-                                                         nsCSSPropertyID aProperty)
+                                                         nsCSSProperty aProperty)
 {
   MOZ_ASSERT(nsCSSProps::PropHasFlags(aProperty,
                                       CSS_PROPERTY_CAN_ANIMATE_ON_COMPOSITOR),
              "inconsistent property flags");
 
   // This function can be called in two ways:  from
   // nsDisplay*::BuildLayer while constructing a layer (with all
   // pointers non-null), or from RestyleManager's handling of
@@ -4431,17 +4431,17 @@ IsItemTooSmallForActiveLayer(nsIFrame* a
           aFrame->PresContext()->AppUnitsPerDevPixel());
   static const int MIN_ACTIVE_LAYER_SIZE_DEV_PIXELS = 16;
   return visibleDevPixels.Size() <
     nsIntSize(MIN_ACTIVE_LAYER_SIZE_DEV_PIXELS, MIN_ACTIVE_LAYER_SIZE_DEV_PIXELS);
 }
 
 static void
 SetAnimationPerformanceWarningForTooSmallItem(nsIFrame* aFrame,
-                                              nsCSSPropertyID aProperty)
+                                              nsCSSProperty aProperty)
 {
   // We use ToNearestPixels() here since ToOutsidePixels causes some sort of
   // errors. See https://bugzilla.mozilla.org/show_bug.cgi?id=1258904#c19
   nsIntRect visibleDevPixels = aFrame->GetVisualOverflowRectRelativeToSelf().ToNearestPixels(
           aFrame->PresContext()->AppUnitsPerDevPixel());
 
   // Set performance warning only if the visible dev pixels is not empty
   // because dev pixels is empty if the frame has 'preserve-3d' style.
--- a/layout/base/nsDisplayList.h
+++ b/layout/base/nsDisplayList.h
@@ -688,17 +688,17 @@ public:
    * already checked that off main thread animations should be sent to
    * the layer.  When they are both null, the animations are added to
    * the layer as pending animations.
    */
   static void AddAnimationsAndTransitionsToLayer(Layer* aLayer,
                                                  nsDisplayListBuilder* aBuilder,
                                                  nsDisplayItem* aItem,
                                                  nsIFrame* aFrame,
-                                                 nsCSSPropertyID aProperty);
+                                                 nsCSSProperty aProperty);
 
   /**
    * A helper class to temporarily set the value of
    * mIsAtRootOfPseudoStackingContext, and temporarily
    * set mCurrentFrame and related state. Also temporarily sets mDirtyRect.
    * aDirtyRect is relative to aForChild.
    */
   class AutoBuildingDisplayList;
--- a/layout/base/nsLayoutUtils.cpp
+++ b/layout/base/nsLayoutUtils.cpp
@@ -471,17 +471,17 @@ HasMatchingAnimations(const nsIFrame* aF
     }
   }
 
   return false;
 }
 
 bool
 nsLayoutUtils::HasCurrentAnimationOfProperty(const nsIFrame* aFrame,
-                                             nsCSSPropertyID aProperty)
+                                             nsCSSProperty aProperty)
 {
   return HasMatchingAnimations(aFrame,
     [&aProperty](KeyframeEffectReadOnly& aEffect)
     {
       return aEffect.IsCurrent() && aEffect.HasAnimationOfProperty(aProperty);
     }
   );
 }
@@ -496,17 +496,17 @@ nsLayoutUtils::HasCurrentTransitions(con
       // so we don't need to null-check the result of GetAnimation().
       return aEffect.IsCurrent() && aEffect.GetAnimation()->AsCSSTransition();
     }
   );
 }
 
 bool
 nsLayoutUtils::HasRelevantAnimationOfProperty(const nsIFrame* aFrame,
-                                              nsCSSPropertyID aProperty)
+                                              nsCSSProperty aProperty)
 {
   return HasMatchingAnimations(aFrame,
     [&aProperty](KeyframeEffectReadOnly& aEffect)
     {
       return (aEffect.IsInEffect() || aEffect.IsCurrent()) &&
              aEffect.HasAnimationOfProperty(aProperty);
     }
   );
@@ -5802,17 +5802,17 @@ DarkenColor(nscolor aColor)
 static bool
 ShouldDarkenColors(nsPresContext* aPresContext)
 {
   return !aPresContext->GetBackgroundColorDraw() &&
          !aPresContext->GetBackgroundImageDraw();
 }
 
 nscolor
-nsLayoutUtils::GetColor(nsIFrame* aFrame, nsCSSPropertyID aProperty)
+nsLayoutUtils::GetColor(nsIFrame* aFrame, nsCSSProperty aProperty)
 {
   nscolor color = aFrame->GetVisitedDependentColor(aProperty);
   if (ShouldDarkenColors(aFrame->PresContext())) {
     color = DarkenColor(color);
   }
   return color;
 }
 
--- a/layout/base/nsLayoutUtils.h
+++ b/layout/base/nsLayoutUtils.h
@@ -13,17 +13,17 @@
 #include "nsBoundingMetrics.h"
 #include "nsChangeHint.h"
 #include "nsFrameList.h"
 #include "mozilla/layout/FrameChildList.h"
 #include "nsThreadUtils.h"
 #include "nsIPrincipal.h"
 #include "FrameMetrics.h"
 #include "nsIWidget.h"
-#include "nsCSSPropertyID.h"
+#include "nsCSSProperty.h"
 #include "nsStyleCoord.h"
 #include "nsStyleConsts.h"
 #include "nsGkAtoms.h"
 #include "nsRuleNode.h"
 #include "imgIContainer.h"
 #include "mozilla/gfx/2D.h"
 #include "Units.h"
 #include "mozilla/ToString.h"
@@ -1551,17 +1551,17 @@ public:
   static nscoord PrefISizeFromInline(nsIFrame* aFrame,
                                      nsRenderingContext* aRenderingContext);
 
   // Implement nsIFrame::GetMinISize in terms of nsIFrame::AddInlineMinISize
   static nscoord MinISizeFromInline(nsIFrame* aFrame,
                                     nsRenderingContext* aRenderingContext);
 
   // Get a suitable foreground color for painting aProperty for aFrame.
-  static nscolor GetColor(nsIFrame* aFrame, nsCSSPropertyID aProperty);
+  static nscolor GetColor(nsIFrame* aFrame, nsCSSProperty aProperty);
 
   // Get a baseline y position in app units that is snapped to device pixels.
   static gfxFloat GetSnappedBaselineY(nsIFrame* aFrame, gfxContext* aContext,
                                       nscoord aY, nscoord aAscent);
   // Ditto for an x position (for vertical text). Note that for vertical-rl
   // writing mode, the ascent value should be negated by the caller.
   static gfxFloat GetSnappedBaselineX(nsIFrame* aFrame, gfxContext* aContext,
                                       nscoord aX, nscoord aAscent);
@@ -2231,32 +2231,32 @@ public:
                                         mozilla::MallocSizeOf aMallocSizeOf,
                                         bool clear);
 
   /**
    * Returns true if the frame has current (i.e. running or scheduled-to-run)
    * animations or transitions for the property.
    */
   static bool HasCurrentAnimationOfProperty(const nsIFrame* aFrame,
-                                            nsCSSPropertyID aProperty);
+                                            nsCSSProperty aProperty);
 
   /**
    * Returns true if the frame has any current CSS transitions.
    * A current transition is any transition that has not yet finished playing
    * including paused transitions.
    */
   static bool HasCurrentTransitions(const nsIFrame* aFrame);
 
   /**
    * Returns true if the frame has current or in-effect (i.e. in before phase,
    * running or filling) animations or transitions for the
    * property.
    */
   static bool HasRelevantAnimationOfProperty(const nsIFrame* aFrame,
-                                             nsCSSPropertyID aProperty);
+                                             nsCSSProperty aProperty);
 
   /**
    * Checks if off-main-thread animations are enabled.
    */
   static bool AreAsyncAnimationsEnabled();
 
   /**
    * Checks if we should warn about animations that can't be async
--- a/layout/generic/TextOverflow.cpp
+++ b/layout/generic/TextOverflow.cpp
@@ -209,17 +209,17 @@ PaintTextShadowCallback(nsRenderingConte
   reinterpret_cast<nsDisplayTextOverflowMarker*>(aData)->
            PaintTextToContext(aCtx, aShadowOffset);
 }
 
 void
 nsDisplayTextOverflowMarker::Paint(nsDisplayListBuilder* aBuilder,
                                    nsRenderingContext*   aCtx)
 {
-  nsCSSPropertyID colorProp = mFrame->StyleContext()->GetTextFillColorProp();
+  nsCSSProperty colorProp = mFrame->StyleContext()->GetTextFillColorProp();
   nscolor foregroundColor = nsLayoutUtils::GetColor(mFrame, colorProp);
 
   // Paint the text-shadows for the overflow marker
   nsLayoutUtils::PaintTextShadow(mFrame, aCtx, mRect, mVisibleRect,
                                  foregroundColor, PaintTextShadowCallback,
                                  (void*)this);
   aCtx->ThebesContext()->SetColor(gfx::Color::FromABGR(foregroundColor));
   PaintTextToContext(aCtx, nsPoint(0, 0));
--- a/layout/generic/nsIFrame.h
+++ b/layout/generic/nsIFrame.h
@@ -612,17 +612,17 @@ public:
     const nsStyle##name_ * Style##name_ () const {                            \
       NS_ASSERTION(mStyleContext, "No style context found!");                 \
       return mStyleContext->Style##name_ ();                                  \
     }
   #include "nsStyleStructList.h"
   #undef STYLE_STRUCT
 
   /** Also forward GetVisitedDependentColor to the style context */
-  nscolor GetVisitedDependentColor(nsCSSPropertyID aProperty)
+  nscolor GetVisitedDependentColor(nsCSSProperty aProperty)
     { return mStyleContext->GetVisitedDependentColor(aProperty); }
 
   /**
    * These methods are to access any additional style contexts that
    * the frame may be holding. These are contexts that are children
    * of the frame's primary context and are NOT used as style contexts
    * for any child frames. These contexts also MUST NOT have any child 
    * contexts whatsoever. If you need to insert style contexts into the
--- a/layout/generic/nsTextFrame.cpp
+++ b/layout/generic/nsTextFrame.cpp
@@ -3935,23 +3935,23 @@ nsTextPaintStyle::InitSelectionColorsAnd
   }
 
   mSelectionTextColor =
     LookAndFeel::GetColor(LookAndFeel::eColorID_TextSelectForeground);
 
   if (mResolveColors) {
     // On MacOS X, we don't exchange text color and BG color.
     if (mSelectionTextColor == NS_DONT_CHANGE_COLOR) {
-      nsCSSPropertyID property = mFrame->IsSVGText()
+      nsCSSProperty property = mFrame->IsSVGText()
                                ? eCSSProperty_fill
                                : mFrame->StyleContext()->GetTextFillColorProp();
       nscoord frameColor = mFrame->GetVisitedDependentColor(property);
       mSelectionTextColor = EnsureDifferentColors(frameColor, mSelectionBGColor);
     } else if (mSelectionTextColor == NS_CHANGE_COLOR_IF_SAME_AS_BG) {
-      nsCSSPropertyID property = mFrame->IsSVGText()
+      nsCSSProperty property = mFrame->IsSVGText()
                                ? eCSSProperty_fill
                                : mFrame->StyleContext()->GetTextFillColorProp();
       nscolor frameColor = mFrame->GetVisitedDependentColor(property);
       if (frameColor == mSelectionBGColor) {
         mSelectionTextColor =
           LookAndFeel::GetColor(LookAndFeel::eColorID_TextSelectForegroundCustom);
       }
     } else {
--- a/layout/inspector/inCSSValueSearch.cpp
+++ b/layout/inspector/inCSSValueSearch.cpp
@@ -31,17 +31,17 @@ inCSSValueSearch::inCSSValueSearch()
     mResultCount(0),
     mPropertyCount(0),
     mIsActive(false),
     mHoldResults(true),
     mReturnRelativeURLs(true),
     mNormalizeChromeURLs(false)
 {
   nsCSSProps::AddRefTable();
-  mProperties = new nsCSSPropertyID[100];
+  mProperties = new nsCSSProperty[100];
 }
 
 inCSSValueSearch::~inCSSValueSearch()
 {
   delete[] mProperties;
   delete mResults;
   nsCSSProps::ReleaseTable();
 }
@@ -217,17 +217,17 @@ inCSSValueSearch::SetNormalizeChromeURLs
 {
   mNormalizeChromeURLs = aNormalizeChromeURLs;
   return NS_OK;
 }
 
 NS_IMETHODIMP 
 inCSSValueSearch::AddPropertyCriteria(const char16_t *aPropName)
 {
-  nsCSSPropertyID prop =
+  nsCSSProperty prop =
     nsCSSProps::LookupProperty(nsDependentString(aPropName),
                                CSSEnabledState::eIgnoreEnabledState);
   mProperties[mPropertyCount] = prop;
   mPropertyCount++;
   return NS_OK;
 }
 
 NS_IMETHODIMP 
--- a/layout/inspector/inCSSValueSearch.h
+++ b/layout/inspector/inCSSValueSearch.h
@@ -28,17 +28,17 @@ public:
 
   inCSSValueSearch();
 
 protected:
   virtual ~inCSSValueSearch();
   nsCOMPtr<inISearchObserver> mObserver;
   nsCOMPtr<nsIDOMDocument> mDocument;
   nsTArray<nsAutoString *>* mResults;
-  nsCSSPropertyID* mProperties;
+  nsCSSProperty* mProperties;
   nsString mLastResult;
   nsString mBaseURL;
   nsString mTextCriteria;
   int32_t mResultCount;
   uint32_t mPropertyCount;
   bool mIsActive;
   bool mHoldResults;
   bool mReturnRelativeURLs;
--- a/layout/inspector/inDOMUtils.cpp
+++ b/layout/inspector/inDOMUtils.cpp
@@ -481,17 +481,17 @@ inDOMUtils::SelectorMatchesElement(nsIDO
   *aMatches = nsCSSRuleProcessor::SelectorListMatches(element, matchingContext,
                                                       sel);
   return NS_OK;
 }
 
 NS_IMETHODIMP
 inDOMUtils::IsInheritedProperty(const nsAString &aPropertyName, bool *_retval)
 {
-  nsCSSPropertyID prop = nsCSSProps::
+  nsCSSProperty prop = nsCSSProps::
     LookupProperty(aPropertyName, CSSEnabledState::eIgnoreEnabledState);
   if (prop == eCSSProperty_UNKNOWN) {
     *_retval = false;
     return NS_OK;
   }
 
   if (prop == eCSSPropertyExtra_variable) {
     *_retval = true;
@@ -526,39 +526,39 @@ inDOMUtils::GetCSSPropertyNames(uint32_t
     maxCount += (eCSSProperty_COUNT_with_aliases - eCSSProperty_COUNT);
   }
 
   char16_t** props =
     static_cast<char16_t**>(moz_xmalloc(maxCount * sizeof(char16_t*)));
 
 #define DO_PROP(_prop)                                                      \
   PR_BEGIN_MACRO                                                            \
-    nsCSSPropertyID cssProp = nsCSSPropertyID(_prop);                           \
+    nsCSSProperty cssProp = nsCSSProperty(_prop);                           \
     if (nsCSSProps::IsEnabled(cssProp, CSSEnabledState::eForAllContent)) {  \
       props[propCount] =                                                    \
         ToNewUnicode(nsDependentCString(kCSSRawProperties[_prop]));         \
       ++propCount;                                                          \
     }                                                                       \
   PR_END_MACRO
 
   // prop is the property id we're considering; propCount is how many properties
   // we've put into props so far.
   uint32_t prop = 0, propCount = 0;
   for ( ; prop < eCSSProperty_COUNT_no_shorthands; ++prop) {
-    if (nsCSSProps::PropertyParseType(nsCSSPropertyID(prop)) !=
+    if (nsCSSProps::PropertyParseType(nsCSSProperty(prop)) !=
         CSS_PROPERTY_PARSE_INACCESSIBLE) {
       DO_PROP(prop);
     }
   }
 
   if (!(aFlags & EXCLUDE_SHORTHANDS)) {
     for ( ; prop < eCSSProperty_COUNT; ++prop) {
       // Some shorthands are also aliases
       if ((aFlags & INCLUDE_ALIASES) ||
-          !nsCSSProps::PropHasFlags(nsCSSPropertyID(prop),
+          !nsCSSProps::PropHasFlags(nsCSSProperty(prop),
                                     CSS_PROPERTY_IS_ALIAS)) {
         DO_PROP(prop);
       }
     }
   }
 
   if (aFlags & INCLUDE_ALIASES) {
     for (prop = eCSSProperty_COUNT; prop < eCSSProperty_COUNT_with_aliases; ++prop) {
@@ -579,17 +579,17 @@ static void InsertNoDuplicates(nsTArray<
 {
   size_t i = aArray.IndexOfFirstElementGt(aString);
   if (i > 0 && aArray[i-1].Equals(aString)) {
     return;
   }
   aArray.InsertElementAt(i, aString);
 }
 
-static void GetKeywordsForProperty(const nsCSSPropertyID aProperty,
+static void GetKeywordsForProperty(const nsCSSProperty aProperty,
                                    nsTArray<nsString>& aArray)
 {
   if (nsCSSProps::IsShorthand(aProperty)) {
     // Shorthand props have no keywords.
     return;
   }
   const nsCSSProps::KTableEntry* keywordTable =
     nsCSSProps::kKeywordTableTable[aProperty];
@@ -670,17 +670,17 @@ static void GetOtherValuesForProperty(co
   }
 }
 
 NS_IMETHODIMP
 inDOMUtils::GetSubpropertiesForCSSProperty(const nsAString& aProperty,
                                            uint32_t* aLength,
                                            char16_t*** aValues)
 {
-  nsCSSPropertyID propertyID =
+  nsCSSProperty propertyID =
     nsCSSProps::LookupProperty(aProperty, CSSEnabledState::eForAllContent);
 
   if (propertyID == eCSSProperty_UNKNOWN) {
     return NS_ERROR_FAILURE;
   }
 
   if (propertyID == eCSSPropertyExtra_variable) {
     *aValues = static_cast<char16_t**>(moz_xmalloc(sizeof(char16_t*)));
@@ -693,62 +693,62 @@ inDOMUtils::GetSubpropertiesForCSSProper
     *aValues = static_cast<char16_t**>(moz_xmalloc(sizeof(char16_t*)));
     (*aValues)[0] = ToNewUnicode(nsCSSProps::GetStringValue(propertyID));
     *aLength = 1;
     return NS_OK;
   }
 
   // Count up how many subproperties we have.
   size_t subpropCount = 0;
-  for (const nsCSSPropertyID *props = nsCSSProps::SubpropertyEntryFor(propertyID);
+  for (const nsCSSProperty *props = nsCSSProps::SubpropertyEntryFor(propertyID);
        *props != eCSSProperty_UNKNOWN; ++props) {
     ++subpropCount;
   }
 
   *aValues =
     static_cast<char16_t**>(moz_xmalloc(subpropCount * sizeof(char16_t*)));
   *aLength = subpropCount;
-  for (const nsCSSPropertyID *props = nsCSSProps::SubpropertyEntryFor(propertyID),
+  for (const nsCSSProperty *props = nsCSSProps::SubpropertyEntryFor(propertyID),
                            *props_start = props;
        *props != eCSSProperty_UNKNOWN; ++props) {
     (*aValues)[props-props_start] = ToNewUnicode(nsCSSProps::GetStringValue(*props));
   }
   return NS_OK;
 }
 
 NS_IMETHODIMP
 inDOMUtils::CssPropertyIsShorthand(const nsAString& aProperty, bool *_retval)
 {
-  nsCSSPropertyID propertyID =
+  nsCSSProperty propertyID =
     nsCSSProps::LookupProperty(aProperty, CSSEnabledState::eForAllContent);
   if (propertyID == eCSSProperty_UNKNOWN) {
     return NS_ERROR_FAILURE;
   }
 
   if (propertyID == eCSSPropertyExtra_variable) {
     *_retval = false;
   } else {
     *_retval = nsCSSProps::IsShorthand(propertyID);
   }
   return NS_OK;
 }
 
 // A helper function that determines whether the given property
 // supports the given type.
 static bool
-PropertySupportsVariant(nsCSSPropertyID aPropertyID, uint32_t aVariant)
+PropertySupportsVariant(nsCSSProperty aPropertyID, uint32_t aVariant)
 {
   if (nsCSSProps::IsShorthand(aPropertyID)) {
     // We need a special case for border here, because while it resets
     // border-image, it can't actually parse an image.
     if (aPropertyID == eCSSProperty_border) {
       return (aVariant & (VARIANT_COLOR | VARIANT_LENGTH)) != 0;
     }
 
-    for (const nsCSSPropertyID* props = nsCSSProps::SubpropertyEntryFor(aPropertyID);
+    for (const nsCSSProperty* props = nsCSSProps::SubpropertyEntryFor(aPropertyID);
          *props != eCSSProperty_UNKNOWN; ++props) {
       if (PropertySupportsVariant(*props, aVariant)) {
         return true;
       }
     }
     return false;
   }
 
@@ -859,17 +859,17 @@ PropertySupportsVariant(nsCSSPropertyID 
 
   return (nsCSSProps::ParserVariant(aPropertyID) & aVariant) != 0;
 }
 
 NS_IMETHODIMP
 inDOMUtils::CssPropertySupportsType(const nsAString& aProperty, uint32_t aType,
                                     bool *_retval)
 {
-  nsCSSPropertyID propertyID =
+  nsCSSProperty propertyID =
     nsCSSProps::LookupProperty(aProperty, CSSEnabledState::eForAllContent);
   if (propertyID == eCSSProperty_UNKNOWN) {
     return NS_ERROR_FAILURE;
   }
 
   if (propertyID >= eCSSProperty_COUNT) {
     *_retval = false;
     return NS_OK;
@@ -920,17 +920,17 @@ inDOMUtils::CssPropertySupportsType(cons
   return NS_OK;
 }
 
 NS_IMETHODIMP
 inDOMUtils::GetCSSValuesForProperty(const nsAString& aProperty,
                                     uint32_t* aLength,
                                     char16_t*** aValues)
 {
-  nsCSSPropertyID propertyID = nsCSSProps::
+  nsCSSProperty propertyID = nsCSSProps::
     LookupProperty(aProperty, CSSEnabledState::eForAllContent);
   if (propertyID == eCSSProperty_UNKNOWN) {
     return NS_ERROR_FAILURE;
   }
 
   nsTArray<nsString> array;
   // We start collecting the values, BUT colors need to go in first, because array
   // needs to stay sorted, and the colors are sorted, so we just append them.
@@ -1055,17 +1055,17 @@ inDOMUtils::IsValidCSSColor(const nsAStr
   return NS_OK;
 }
 
 NS_IMETHODIMP
 inDOMUtils::CssPropertyIsValid(const nsAString& aPropertyName,
                                const nsAString& aPropertyValue,
                                bool *_retval)
 {
-  nsCSSPropertyID propertyID = nsCSSProps::
+  nsCSSProperty propertyID = nsCSSProps::
     LookupProperty(aPropertyName, CSSEnabledState::eIgnoreEnabledState);
 
   if (propertyID == eCSSProperty_UNKNOWN) {
     *_retval = false;
     return NS_OK;
   }
 
   if (propertyID == eCSSPropertyExtra_variable) {
--- a/layout/mathml/nsMathMLChar.cpp
+++ b/layout/mathml/nsMathMLChar.cpp
@@ -2119,17 +2119,17 @@ nsMathMLChar::PaintForeground(nsPresCont
     // normal drawing if there is nothing special about this char
     // Set default context to the parent context
     styleContext = parentContext;
   }
 
   RefPtr<gfxContext> thebesContext = aRenderingContext.ThebesContext();
 
   // Set color ...
-  nsCSSPropertyID colorProp = styleContext->GetTextFillColorProp();
+  nsCSSProperty colorProp = styleContext->GetTextFillColorProp();
   nscolor fgColor = styleContext->GetVisitedDependentColor(colorProp);
   if (aIsSelected) {
     // get color to use for selection from the look&feel object
     fgColor = LookAndFeel::GetColor(LookAndFeel::eColorID_TextSelectForeground,
                                     fgColor);
   }
   thebesContext->SetColor(Color::FromABGR(fgColor));
   thebesContext->Save();
--- a/layout/mathml/nsMathMLFrame.cpp
+++ b/layout/mathml/nsMathMLFrame.cpp
@@ -359,17 +359,17 @@ void nsDisplayMathMLBar::Paint(nsDisplay
                                nsRenderingContext* aCtx)
 {
   // paint the bar with the current text color
   DrawTarget* drawTarget = aCtx->GetDrawTarget();
   Rect rect =
     NSRectToNonEmptySnappedRect(mRect + ToReferenceFrame(),
                                 mFrame->PresContext()->AppUnitsPerDevPixel(),
                                 *drawTarget);
-  nsCSSPropertyID colorProp = mFrame->StyleContext()->GetTextFillColorProp();
+  nsCSSProperty colorProp = mFrame->StyleContext()->GetTextFillColorProp();
   ColorPattern color(ToDeviceColor(
                                  mFrame->GetVisitedDependentColor(colorProp)));
   drawTarget->FillRect(rect, color);
 }
 
 void
 nsMathMLFrame::DisplayBar(nsDisplayListBuilder* aBuilder,
                           nsIFrame* aFrame, const nsRect& aRect,
--- a/layout/mathml/nsMathMLmencloseFrame.cpp
+++ b/layout/mathml/nsMathMLmencloseFrame.cpp
@@ -774,17 +774,17 @@ void nsDisplayNotation::Paint(nsDisplayL
   nsPresContext* presContext = mFrame->PresContext();
 
   Float strokeWidth = presContext->AppUnitsToGfxUnits(mThickness);
 
   Rect rect = NSRectToRect(mRect + ToReferenceFrame(),
                            presContext->AppUnitsPerDevPixel());
   rect.Deflate(strokeWidth / 2.f);
 
-  nsCSSPropertyID colorProp = mFrame->StyleContext()->GetTextFillColorProp();
+  nsCSSProperty colorProp = mFrame->StyleContext()->GetTextFillColorProp();
   ColorPattern color(ToDeviceColor(
                                  mFrame->GetVisitedDependentColor(colorProp)));
 
   StrokeOptions strokeOptions(strokeWidth);
 
   switch(mType)
   {
     case NOTATION_CIRCLE: {
--- a/layout/mathml/nsMathMLmfracFrame.cpp
+++ b/layout/mathml/nsMathMLmfracFrame.cpp
@@ -624,17 +624,17 @@ void nsDisplayMathMLSlash::Paint(nsDispl
 {
   DrawTarget& aDrawTarget = *aCtx->GetDrawTarget();
 
   // get the gfxRect
   nsPresContext* presContext = mFrame->PresContext();
   Rect rect = NSRectToRect(mRect + ToReferenceFrame(),
                            presContext->AppUnitsPerDevPixel());
   
-  nsCSSPropertyID colorProp = mFrame->StyleContext()->GetTextFillColorProp();
+  nsCSSProperty colorProp = mFrame->StyleContext()->GetTextFillColorProp();
   ColorPattern color(ToDeviceColor(
                                  mFrame->GetVisitedDependentColor(colorProp)));
  
   // draw the slash as a parallelogram 
   Point delta = Point(presContext->AppUnitsToGfxUnits(mThickness), 0);
   RefPtr<PathBuilder> builder = aDrawTarget.CreatePathBuilder();
   if (mRTL) {
     builder->MoveTo(rect.TopLeft());
--- a/layout/style/AnimationCommon.cpp
+++ b/layout/style/AnimationCommon.cpp
@@ -4,17 +4,17 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "AnimationCommon.h"
 #include "nsTransitionManager.h"
 #include "nsAnimationManager.h"
 
 #include "ActiveLayerTracker.h"
 #include "gfxPlatform.h"
-#include "nsCSSPropertyIDSet.h"
+#include "nsCSSPropertySet.h"
 #include "nsCSSValue.h"
 #include "nsCycleCollectionParticipant.h"
 #include "nsStyleContext.h"
 #include "nsIFrame.h"
 #include "nsLayoutUtils.h"
 #include "FrameLayerBuilder.h"
 #include "nsDisplayList.h"
 #include "mozilla/AnimationUtils.h"
--- a/layout/style/CSSVariableImageTable.h
+++ b/layout/style/CSSVariableImageTable.h
@@ -4,24 +4,24 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 /* A global table that tracks images referenced by CSS variables. */
 
 #ifndef mozilla_CSSVariableImageTable_h
 #define mozilla_CSSVariableImageTable_h
 
 #include "nsClassHashtable.h"
-#include "nsCSSPropertyID.h"
+#include "nsCSSProperty.h"
 #include "nsCSSValue.h"
 #include "nsStyleContext.h"
 #include "nsTArray.h"
 
 /**
  * CSSVariableImageTable maintains a global mapping
- *   (nsStyleContext, nsCSSPropertyID) -> nsTArray<ImageValue>
+ *   (nsStyleContext, nsCSSProperty) -> nsTArray<ImageValue>
  * which allows us to track the relationship between CSS property values
  * involving variables and any images they may reference.
  *
  * When properties like background-image contain a normal url(), the
  * Declaration's data block will hold a reference to the ImageValue.  When a
  * token stream is used, the Declaration only holds on to an
  * nsCSSValueTokenStream object, and the ImageValue would only exist for the
  * duration of nsRuleNode::WalkRuleTree, in the AutoCSSValueArray.  So instead
@@ -39,17 +39,17 @@
  */
 
 namespace mozilla {
 namespace CSSVariableImageTable {
 
 namespace detail {
 
 typedef nsTArray<RefPtr<css::ImageValue>> ImageValueArray;
-typedef nsClassHashtable<nsGenericHashKey<nsCSSPropertyID>, ImageValueArray>
+typedef nsClassHashtable<nsGenericHashKey<nsCSSProperty>, ImageValueArray>
         PerPropertyImageHashtable;
 typedef nsClassHashtable<nsPtrHashKey<nsStyleContext>, PerPropertyImageHashtable>
         CSSVariableImageHashtable;
 
 inline CSSVariableImageHashtable& GetTable()
 {
   static CSSVariableImageHashtable imageTable;
   return imageTable;
@@ -62,27 +62,27 @@ inline bool& IsReplacing()
   return isReplacing;
 }
 #endif
 
 } // namespace detail
 
 /**
  * ReplaceAll() allows callers to replace the ImageValues associated with a
- * (nsStyleContext, nsCSSPropertyID) pair. The memory used by the previous list of
+ * (nsStyleContext, nsCSSProperty) pair. The memory used by the previous list of
  * ImageValues is automatically released.
  *
  * @param aContext The style context the ImageValues are associated with.
  * @param aProp    The CSS property the ImageValues are associated with.
  * @param aFunc    A lambda that calls CSSVariableImageTable::Add() to add new
  *                 ImageValues which will replace the old ones.
  */
 template <typename Lambda>
 inline void ReplaceAll(nsStyleContext* aContext,
-                       nsCSSPropertyID aProp,
+                       nsCSSProperty aProp,
                        Lambda aFunc)
 {
   MOZ_ASSERT(aContext);
 
   auto& imageTable = detail::GetTable();
 
   // Clear the existing image array, if any, for this property.
   {
@@ -129,17 +129,17 @@ inline void ReplaceAll(nsStyleContext* a
 /**
  * Adds a new ImageValue @aValue to the CSSVariableImageTable, which will be
  * associated with @aContext and @aProp.
  *
  * It's illegal to call this function outside of a lambda passed to
  * CSSVariableImageTable::ReplaceAll().
  */
 inline void
-Add(nsStyleContext* aContext, nsCSSPropertyID aProp, css::ImageValue* aValue)
+Add(nsStyleContext* aContext, nsCSSProperty aProp, css::ImageValue* aValue)
 {
   MOZ_ASSERT(aValue);
   MOZ_ASSERT(aContext);
   MOZ_ASSERT(detail::IsReplacing());
 
   auto& imageTable = detail::GetTable();
 
   // Ensure there's a per-property image table for this style context.
--- a/layout/style/Declaration.cpp
+++ b/layout/style/Declaration.cpp
@@ -142,29 +142,29 @@ Declaration::MapsImportantInheritedStyle
                                  "important data");
   if (mImportantVariables && mImportantVariables->Count() != 0) {
     return true;
   }
   return mImportantData ? mImportantData->HasInheritedStyleData() : false;
 }
 
 void
-Declaration::ValueAppended(nsCSSPropertyID aProperty)
+Declaration::ValueAppended(nsCSSProperty aProperty)
 {
   MOZ_ASSERT(!mData && !mImportantData,
              "should only be called while expanded");
   MOZ_ASSERT(!nsCSSProps::IsShorthand(aProperty),
              "shorthands forbidden");
   // order IS important for CSS, so remove and add to the end
   mOrder.RemoveElement(static_cast<uint32_t>(aProperty));
   mOrder.AppendElement(static_cast<uint32_t>(aProperty));
 }
 
 void
-Declaration::RemoveProperty(nsCSSPropertyID aProperty)
+Declaration::RemoveProperty(nsCSSProperty aProperty)
 {
   MOZ_ASSERT(0 <= aProperty && aProperty < eCSSProperty_COUNT);
 
   nsCSSExpandedDataBlock data;
   ExpandTo(&data);
   MOZ_ASSERT(!mData && !mImportantData, "Expand didn't null things out");
 
   if (nsCSSProps::IsShorthand(aProperty)) {
@@ -177,29 +177,29 @@ Declaration::RemoveProperty(nsCSSPropert
     data.ClearLonghandProperty(aProperty);
     mOrder.RemoveElement(static_cast<uint32_t>(aProperty));
   }
 
   CompressFrom(&data);
 }
 
 bool
-Declaration::HasProperty(nsCSSPropertyID aProperty) const
+Declaration::HasProperty(nsCSSProperty aProperty) const
 {
   MOZ_ASSERT(0 <= aProperty && aProperty < eCSSProperty_COUNT_no_shorthands,
              "property ID out of range");
 
   nsCSSCompressedDataBlock *data = GetValueIsImportant(aProperty)
                                       ? mImportantData : mData;
   const nsCSSValue *val = data->ValueFor(aProperty);
   return !!val;
 }
 
 bool
-Declaration::AppendValueToString(nsCSSPropertyID aProperty,
+Declaration::AppendValueToString(nsCSSProperty aProperty,
                                  nsAString& aResult,
                                  nsCSSValue::Serialization aSerialization) const
 {
   MOZ_ASSERT(0 <= aProperty && aProperty < eCSSProperty_COUNT_no_shorthands,
              "property ID out of range");
 
   nsCSSCompressedDataBlock *data = GetValueIsImportant(aProperty)
                                       ? mImportantData : mData;
@@ -208,31 +208,31 @@ Declaration::AppendValueToString(nsCSSPr
     return false;
   }
 
   val->AppendToString(aProperty, aResult, aSerialization);
   return true;
 }
 
 void
-Declaration::GetValue(nsCSSPropertyID aProperty, nsAString& aValue) const
+Declaration::GetValue(nsCSSProperty aProperty, nsAString& aValue) const
 {
   GetValue(aProperty, aValue, nsCSSValue::eNormalized);
 }
 
 void
-Declaration::GetAuthoredValue(nsCSSPropertyID aProperty, nsAString& aValue) const
+Declaration::GetAuthoredValue(nsCSSProperty aProperty, nsAString& aValue) const
 {
   GetValue(aProperty, aValue, nsCSSValue::eAuthorSpecified);
 }
 
 static void
 AppendSingleImageLayerPositionValue(const nsCSSValue& aPositionX,
                                     const nsCSSValue& aPositionY,
-                                    const nsCSSPropertyID aTable[],
+                                    const nsCSSProperty aTable[],
                                     nsAString& aValue,
                                     nsCSSValue::Serialization aSerialization)
 {
   // We need to make sure that we don't serialize to an invalid 3-value form.
   // The 3-value form is only valid if both edges are present.
   const nsCSSValue &xEdge = aPositionX.GetArrayValue()->Item(0);
   const nsCSSValue &xOffset = aPositionX.GetArrayValue()->Item(1);
   const nsCSSValue &yEdge = aPositionY.GetArrayValue()->Item(0);
@@ -259,17 +259,17 @@ AppendSingleImageLayerPositionValue(cons
                             aValue, aSerialization);
 }
 
 void
 Declaration::GetImageLayerValue(
                    nsCSSCompressedDataBlock *data,
                    nsAString& aValue,
                    nsCSSValue::Serialization aSerialization,
-                   const nsCSSPropertyID aTable[]) const
+                   const nsCSSProperty aTable[]) const
 {
   // We know from our caller that all subproperties were specified.
   // However, we still can't represent that in the shorthand unless
   // they're all lists of the same length.  So if they're different
   // lengths, we need to bail out.
   // We also need to bail out if an item has background-clip and
   // background-origin that are different and not the default
   // values.  (We omit them if they're both default.)
@@ -462,17 +462,17 @@ Declaration::GetImageLayerValue(
   }
 }
 
 void
 Declaration::GetImageLayerPositionValue(
                    nsCSSCompressedDataBlock *data,
                    nsAString& aValue,
                    nsCSSValue::Serialization aSerialization,
-                   const nsCSSPropertyID aTable[]) const
+                   const nsCSSProperty aTable[]) const
 {
   // We know from above that all subproperties were specified.
   // However, we still can't represent that in the shorthand unless
   // they're all lists of the same length.  So if they're different
   // lengths, we need to bail out.
   const nsCSSValueList *positionX =
     data->ValueFor(aTable[nsStyleImageLayers::positionX])->GetListValue();
   const nsCSSValueList *positionY =
@@ -491,17 +491,17 @@ Declaration::GetImageLayerPositionValue(
       return;
     }
     aValue.Append(char16_t(','));
     aValue.Append(char16_t(' '));
   }
 }
 
 void
-Declaration::GetValue(nsCSSPropertyID aProperty, nsAString& aValue,
+Declaration::GetValue(nsCSSProperty aProperty, nsAString& aValue,
                       nsCSSValue::Serialization aSerialization) const
 {
   aValue.Truncate(0);
 
   // simple properties are easy.
   if (!nsCSSProps::IsShorthand(aProperty)) {
     AppendValueToString(aProperty, aValue, aSerialization);
     return;
@@ -610,17 +610,17 @@ Declaration::GetValue(nsCSSPropertyID aP
 
   nsCSSCompressedDataBlock *data = importantCount ? mImportantData : mData;
   switch (aProperty) {
     case eCSSProperty_margin:
     case eCSSProperty_padding:
     case eCSSProperty_border_color:
     case eCSSProperty_border_style:
     case eCSSProperty_border_width: {
-      const nsCSSPropertyID* subprops =
+      const nsCSSProperty* subprops =
         nsCSSProps::SubpropertyEntryFor(aProperty);
       MOZ_ASSERT(nsCSSProps::GetStringValue(subprops[0]).Find("-top") !=
                  kNotFound, "first subprop must be top");
       MOZ_ASSERT(nsCSSProps::GetStringValue(subprops[1]).Find("-right") !=
                  kNotFound, "second subprop must be right");
       MOZ_ASSERT(nsCSSProps::GetStringValue(subprops[2]).Find("-bottom") !=
                  kNotFound, "third subprop must be bottom");
       MOZ_ASSERT(nsCSSProps::GetStringValue(subprops[3]).Find("-left") !=
@@ -632,17 +632,17 @@ Declaration::GetValue(nsCSSPropertyID aP
         data->ValueFor(subprops[3])
       };
       nsCSSValue::AppendSidesShorthandToString(subprops, vals, aValue,
                                                aSerialization);
       break;
     }
     case eCSSProperty_border_radius:
     case eCSSProperty__moz_outline_radius: {
-      const nsCSSPropertyID* subprops =
+      const nsCSSProperty* subprops =
         nsCSSProps::SubpropertyEntryFor(aProperty);
       const nsCSSValue* vals[4] = {
         data->ValueFor(subprops[0]),
         data->ValueFor(subprops[1]),
         data->ValueFor(subprops[2]),
         data->ValueFor(subprops[3])
       };
       nsCSSValue::AppendBasicShapeRadiusToString(subprops, vals, aValue,
@@ -704,23 +704,23 @@ Declaration::GetValue(nsCSSPropertyID aP
             eCSSUnit_None ||
           data->ValueFor(eCSSProperty_border_bottom_colors)->GetUnit() !=
             eCSSUnit_None ||
           data->ValueFor(eCSSProperty_border_left_colors)->GetUnit() !=
             eCSSUnit_None) {
         break;
       }
 
-      const nsCSSPropertyID* subproptables[3] = {
+      const nsCSSProperty* subproptables[3] = {
         nsCSSProps::SubpropertyEntryFor(eCSSProperty_border_color),
         nsCSSProps::SubpropertyEntryFor(eCSSProperty_border_style),
         nsCSSProps::SubpropertyEntryFor(eCSSProperty_border_width)
       };
       bool match = true;
-      for (const nsCSSPropertyID** subprops = subproptables,
+      for (const nsCSSProperty** subprops = subproptables,
                **subprops_end = ArrayEnd(subproptables);
            subprops < subprops_end; ++subprops) {
         const nsCSSValue *firstSide = data->ValueFor((*subprops)[0]);
         for (int32_t side = 1; side < 4; ++side) {
           const nsCSSValue *otherSide =
             data->ValueFor((*subprops)[side]);
           if (*firstSide != *otherSide)
             match = false;
@@ -739,17 +739,17 @@ Declaration::GetValue(nsCSSPropertyID aP
     case eCSSProperty_border_bottom:
     case eCSSProperty_border_left:
     case eCSSProperty_border_inline_start:
     case eCSSProperty_border_inline_end:
     case eCSSProperty_border_block_start:
     case eCSSProperty_border_block_end:
     case eCSSProperty__moz_column_rule:
     case eCSSProperty_outline: {
-      const nsCSSPropertyID* subprops =
+      const nsCSSProperty* subprops =
         nsCSSProps::SubpropertyEntryFor(aProperty);
       MOZ_ASSERT(StringEndsWith(nsCSSProps::GetStringValue(subprops[2]),
                                 NS_LITERAL_CSTRING("-color")),
                  "third subprop must be the color property");
       const nsCSSValue *colorValue = data->ValueFor(subprops[2]);
       bool isMozUseTextColor =
         colorValue->GetUnit() == eCSSUnit_Enumerated &&
         colorValue->GetIntValue() == NS_STYLE_COLOR_MOZ_USE_TEXT_COLOR;
@@ -908,25 +908,25 @@ Declaration::GetValue(nsCSSPropertyID aP
         }
         aValue.Append(char16_t(' '));
         family->AppendToString(eCSSProperty_font_family, aValue,
                                aSerialization);
       }
       break;
     }
     case eCSSProperty_font_variant: {
-      const nsCSSPropertyID *subprops =
+      const nsCSSProperty *subprops =
         nsCSSProps::SubpropertyEntryFor(aProperty);
       const nsCSSValue *fontVariantLigatures =
         data->ValueFor(eCSSProperty_font_variant_ligatures);
 
       // all subproperty values normal? system font?
       bool normalLigs = true, normalNonLigs = true, systemFont = true,
            hasSystem = false;
-      for (const nsCSSPropertyID *sp = subprops; *sp != eCSSProperty_UNKNOWN; sp++) {
+      for (const nsCSSProperty *sp = subprops; *sp != eCSSProperty_UNKNOWN; sp++) {
         const nsCSSValue *spVal = data->ValueFor(*sp);
         bool isNormal = (spVal->GetUnit() == eCSSUnit_Normal);
         if (*sp == eCSSProperty_font_variant_ligatures) {
           normalLigs = normalLigs && isNormal;
         } else {
           normalNonLigs = normalNonLigs && isNormal;
         }
         bool isSystem = (spVal->GetUnit() == eCSSUnit_System_Font);
@@ -946,17 +946,17 @@ Declaration::GetValue(nsCSSPropertyID aP
                                              aSerialization);
       } else if (ligsNone || hasSystem) {
         // ligatures none but other values are non-normal ==> empty
         // at least one but not all values are system font ==> empty
         return;
       } else {
         // iterate over and append non-normal values
         bool appendSpace = false;
-        for (const nsCSSPropertyID *sp = subprops;
+        for (const nsCSSProperty *sp = subprops;
              *sp != eCSSProperty_UNKNOWN; sp++) {
           const nsCSSValue *spVal = data->ValueFor(*sp);
           if (spVal && spVal->GetUnit() != eCSSUnit_Normal) {
             if (appendSpace) {
               aValue.Append(char16_t(' '));
             } else {
               appendSpace = true;
             }
@@ -1085,17 +1085,17 @@ Declaration::GetValue(nsCSSPropertyID aP
         if (pro || dur || tim || del) {
           // Lists not all the same length, can't use shorthand.
           aValue.Truncate();
         }
       }
       break;
     }
     case eCSSProperty_animation: {
-      const nsCSSPropertyID* subprops =
+      const nsCSSProperty* subprops =
         nsCSSProps::SubpropertyEntryFor(eCSSProperty_animation);
       static const size_t numProps = 8;
       MOZ_ASSERT(subprops[numProps] == eCSSProperty_UNKNOWN,
                  "unexpected number of subproperties");
       const nsCSSValue* values[numProps];
       const nsCSSValueList* lists[numProps];
 
       for (uint32_t i = 0; i < numProps; ++i) {
@@ -1145,63 +1145,63 @@ Declaration::GetValue(nsCSSPropertyID aP
       const nsCSSValue &startValue =
         *data->ValueFor(eCSSProperty_marker_start);
       if (endValue == midValue && midValue == startValue)
         AppendValueToString(eCSSProperty_marker_end, aValue, aSerialization);
       break;
     }
     case eCSSProperty__moz_columns: {
       // Two values, column-count and column-width, separated by a space.
-      const nsCSSPropertyID* subprops =
+      const nsCSSProperty* subprops =
         nsCSSProps::SubpropertyEntryFor(aProperty);
       AppendValueToString(subprops[0], aValue, aSerialization);
       aValue.Append(char16_t(' '));
       AppendValueToString(subprops[1], aValue, aSerialization);
       break;
     }
     case eCSSProperty_flex: {
       // flex-grow, flex-shrink, flex-basis, separated by single space
-      const nsCSSPropertyID* subprops =
+      const nsCSSProperty* subprops =
         nsCSSProps::SubpropertyEntryFor(aProperty);
 
       AppendValueToString(subprops[0], aValue, aSerialization);
       aValue.Append(char16_t(' '));
       AppendValueToString(subprops[1], aValue, aSerialization);
       aValue.Append(char16_t(' '));
       AppendValueToString(subprops[2], aValue, aSerialization);
       break;
     }
     case eCSSProperty_flex_flow: {
       // flex-direction, flex-wrap, separated by single space
-      const nsCSSPropertyID* subprops =
+      const nsCSSProperty* subprops =
         nsCSSProps::SubpropertyEntryFor(aProperty);
       MOZ_ASSERT(subprops[2] == eCSSProperty_UNKNOWN,
                  "must have exactly two subproperties");
 
       AppendValueToString(subprops[0], aValue, aSerialization);
       aValue.Append(char16_t(' '));
       AppendValueToString(subprops[1], aValue, aSerialization);
       break;
     }
     case eCSSProperty_grid_row:
     case eCSSProperty_grid_column: {
       // grid-{row,column}-start, grid-{row,column}-end, separated by a slash
-      const nsCSSPropertyID* subprops =
+      const nsCSSProperty* subprops =
         nsCSSProps::SubpropertyEntryFor(aProperty);
       MOZ_ASSERT(subprops[2] == eCSSProperty_UNKNOWN,
                  "must have exactly two subproperties");
 
       // TODO: should we simplify when possible?
       AppendValueToString(subprops[0], aValue, aSerialization);
       aValue.AppendLiteral(" / ");
       AppendValueToString(subprops[1], aValue, aSerialization);
       break;
     }
     case eCSSProperty_grid_area: {
-      const nsCSSPropertyID* subprops =
+      const nsCSSProperty* subprops =
         nsCSSProps::SubpropertyEntryFor(aProperty);
       MOZ_ASSERT(subprops[4] == eCSSProperty_UNKNOWN,
                  "must have exactly four subproperties");
 
       // TODO: should we simplify when possible?
       AppendValueToString(subprops[0], aValue, aSerialization);
       aValue.AppendLiteral(" / ");
       AppendValueToString(subprops[1], aValue, aSerialization);
@@ -1356,17 +1356,17 @@ Declaration::GetValue(nsCSSPropertyID aP
       if (columnsValue.GetUnit() != eCSSUnit_None) {
         aValue.AppendLiteral(" / ");
         AppendValueToString(eCSSProperty_grid_template_columns,
                             aValue, aSerialization);
       }
       break;
     }
     case eCSSProperty_grid_gap: {
-      const nsCSSPropertyID* subprops =
+      const nsCSSProperty* subprops =
         nsCSSProps::SubpropertyEntryFor(aProperty);
       MOZ_ASSERT(subprops[2] == eCSSProperty_UNKNOWN,
                  "must have exactly two subproperties");
 
       nsAutoString val1, val2;
       AppendValueToString(subprops[0], val1, aSerialization);
       AppendValueToString(subprops[1], val2, aSerialization);
       if (val1 == val2) {
@@ -1396,17 +1396,17 @@ Declaration::GetValue(nsCSSPropertyID aP
       if (!isDefaultColor) {
         AppendValueToString(eCSSProperty_text_emphasis_color,
                             aValue, aSerialization);
       }
       break;
     }
     case eCSSProperty__moz_transform: {
       // shorthands that are just aliases with different parsing rules
-      const nsCSSPropertyID* subprops =
+      const nsCSSProperty* subprops =
         nsCSSProps::SubpropertyEntryFor(aProperty);
       MOZ_ASSERT(subprops[1] == eCSSProperty_UNKNOWN,
                  "must have exactly one subproperty");
       AppendValueToString(subprops[0], aValue, aSerialization);
       break;
     }
     case eCSSProperty_scroll_snap_type: {
       const nsCSSValue& xValue =
@@ -1453,31 +1453,31 @@ Declaration::GetValue(nsCSSPropertyID aP
       MOZ_ASSERT(false, "no other shorthands");
       break;
   }
 }
 
 bool
 Declaration::GetValueIsImportant(const nsAString& aProperty) const
 {
-  nsCSSPropertyID propID = nsCSSProps::
+  nsCSSProperty propID = nsCSSProps::
     LookupProperty(aProperty, CSSEnabledState::eIgnoreEnabledState);
   if (propID == eCSSProperty_UNKNOWN) {
     return false;
   }
   if (propID == eCSSPropertyExtra_variable) {
     const nsSubstring& variableName =
       Substring(aProperty, CSS_CUSTOM_NAME_PREFIX_LENGTH);
     return GetVariableValueIsImportant(variableName);
   }
   return GetValueIsImportant(propID);
 }
 
 bool
-Declaration::GetValueIsImportant(nsCSSPropertyID aProperty) const
+Declaration::GetValueIsImportant(nsCSSProperty aProperty) const
 {
   if (!mImportantData)
     return false;
 
   // Calling ValueFor is inefficient, but we can assume '!important' is rare.
 
   if (!nsCSSProps::IsShorthand(aProperty)) {
     return mImportantData->ValueFor(aProperty) != nullptr;
@@ -1492,17 +1492,17 @@ Declaration::GetValueIsImportant(nsCSSPr
     if (!mImportantData->ValueFor(*p)) {
       return false;
     }
   }
   return true;
 }
 
 void
-Declaration::AppendPropertyAndValueToString(nsCSSPropertyID aProperty,
+Declaration::AppendPropertyAndValueToString(nsCSSProperty aProperty,
                                             nsAutoString& aValue,
                                             nsAString& aResult) const
 {
   MOZ_ASSERT(0 <= aProperty && aProperty < eCSSProperty_COUNT,
              "property enum out of range");
   MOZ_ASSERT((aProperty < eCSSProperty_COUNT_no_shorthands) == aValue.IsEmpty(),
              "aValue should be given for shorthands but not longhands");
   AppendASCIItoUTF16(nsCSSProps::GetStringValue(aProperty), aResult);
@@ -1583,54 +1583,54 @@ Declaration::ToString(nsAString& aString
     systemFontData->ValueFor(eCSSProperty__x_system_font);
   const bool haveSystemFont = systemFont &&
                                 systemFont->GetUnit() != eCSSUnit_None &&
                                 systemFont->GetUnit() != eCSSUnit_Null;
   bool didSystemFont = false;
 
   int32_t count = mOrder.Length();
   int32_t index;
-  AutoTArray<nsCSSPropertyID, 16> shorthandsUsed;
+  AutoTArray<nsCSSProperty, 16> shorthandsUsed;
   for (index = 0; index < count; index++) {
-    nsCSSPropertyID property = GetPropertyAt(index);
+    nsCSSProperty property = GetPropertyAt(index);
 
     if (property == eCSSPropertyExtra_variable) {
       uint32_t variableIndex = mOrder[index] - eCSSProperty_COUNT;
       AppendVariableAndValueToString(mVariableOrder[variableIndex], aString);
       continue;
     }
 
     if (!nsCSSProps::IsEnabled(property, CSSEnabledState::eForAllContent)) {
       continue;
     }
     bool doneProperty = false;
 
     // If we already used this property in a shorthand, skip it.
     if (shorthandsUsed.Length() > 0) {
-      for (const nsCSSPropertyID *shorthands =
+      for (const nsCSSProperty *shorthands =
              nsCSSProps::ShorthandsContaining(property);
            *shorthands != eCSSProperty_UNKNOWN; ++shorthands) {
         if (shorthandsUsed.Contains(*shorthands)) {
           doneProperty = true;
           break;
         }
       }
       if (doneProperty)
         continue;
     }
 
     // Try to use this property in a shorthand.
     nsAutoString value;
-    for (const nsCSSPropertyID *shorthands =
+    for (const nsCSSProperty *shorthands =
            nsCSSProps::ShorthandsContaining(property);
          *shorthands != eCSSProperty_UNKNOWN; ++shorthands) {
       // ShorthandsContaining returns the shorthands in order from those
       // that contain the most subproperties to those that contain the
       // least, which is exactly the order we want to test them.
-      nsCSSPropertyID shorthand = *shorthands;
+      nsCSSProperty shorthand = *shorthands;
 
       GetValue(shorthand, value);
 
       // in the system font case, skip over font-variant shorthand, since all
       // subproperties are already dealt with via the font shorthand
       if (shorthand == eCSSProperty_font_variant &&
           value.EqualsLiteral("-moz-use-system-font")) {
         continue;
@@ -1709,17 +1709,17 @@ Declaration::List(FILE* out, int32_t aIn
 }
 #endif
 
 bool
 Declaration::GetNthProperty(uint32_t aIndex, nsAString& aReturn) const
 {
   aReturn.Truncate();
   if (aIndex < mOrder.Length()) {
-    nsCSSPropertyID property = GetPropertyAt(aIndex);
+    nsCSSProperty property = GetPropertyAt(aIndex);
     if (property == eCSSPropertyExtra_variable) {
       GetCustomPropertyNameAt(aIndex, aReturn);
       return true;
     }
     if (0 <= property) {
       AppendASCIItoUTF16(nsCSSProps::GetStringValue(property), aReturn);
       return true;
     }
--- a/layout/style/Declaration.h
+++ b/layout/style/Declaration.h
@@ -16,17 +16,17 @@
 #ifndef MOZILLA_INTERNAL_API
 #error "This file should only be included within libxul"
 #endif
 
 #include "mozilla/Attributes.h"
 #include "mozilla/MemoryReporting.h"
 #include "CSSVariableDeclarations.h"
 #include "nsCSSDataBlock.h"
-#include "nsCSSPropertyID.h"
+#include "nsCSSProperty.h"
 #include "nsCSSProps.h"
 #include "nsIStyleRule.h"
 #include "nsStringFwd.h"
 #include "nsTArray.h"
 #include <stdio.h>
 
 // feec07b8-3fe6-491e-90d5-cc93f853e048
 #define NS_CSS_DECLARATION_IMPL_CID \
@@ -111,29 +111,29 @@ public:
   virtual void List(FILE* out = stdout, int32_t aIndent = 0) const override;
 #endif
 
   /**
    * |ValueAppended| must be called to maintain this declaration's
    * |mOrder| whenever a property is parsed into an expanded data block
    * for this declaration.  aProperty must not be a shorthand.
    */
-  void ValueAppended(nsCSSPropertyID aProperty);
+  void ValueAppended(nsCSSProperty aProperty);
 
-  void RemoveProperty(nsCSSPropertyID aProperty);
+  void RemoveProperty(nsCSSProperty aProperty);
 
-  bool HasProperty(nsCSSPropertyID aProperty) const;
+  bool HasProperty(nsCSSProperty aProperty) const;
 
-  void GetValue(nsCSSPropertyID aProperty, nsAString& aValue) const;
-  void GetAuthoredValue(nsCSSPropertyID aProperty, nsAString& aValue) const;
+  void GetValue(nsCSSProperty aProperty, nsAString& aValue) const;
+  void GetAuthoredValue(nsCSSProperty aProperty, nsAString& aValue) const;
 
   bool HasImportantData() const {
     return mImportantData || mImportantVariables;
   }
-  bool GetValueIsImportant(nsCSSPropertyID aProperty) const;
+  bool GetValueIsImportant(nsCSSProperty aProperty) const;
   bool GetValueIsImportant(const nsAString& aProperty) const;
 
   /**
    * Adds a custom property declaration to this object.
    *
    * @param aName The variable name (i.e., without the "--" prefix).
    * @param aType The type of value the variable has.
    * @param aValue The value of the variable, if aType is
@@ -237,17 +237,17 @@ public:
    * declaration with the matching value from |aFromBlock|.
    * This method may only be called on a mutable declaration.
    * It will fail (returning false) if |aProperty| is shorthand,
    * is not already in this declaration, or does not have the indicated
    * importance level.  If it returns true, it erases the value in
    * |aFromBlock|.  |aChanged| is set to true if the declaration
    * changed as a result of the call, and to false otherwise.
    */
-  bool TryReplaceValue(nsCSSPropertyID aProperty, bool aIsImportant,
+  bool TryReplaceValue(nsCSSProperty aProperty, bool aIsImportant,
                          nsCSSExpandedDataBlock& aFromBlock,
                          bool* aChanged)
   {
     AssertMutable();
     MOZ_ASSERT(mData, "called while expanded");
 
     if (nsCSSProps::IsShorthand(aProperty)) {
       *aChanged = false;
@@ -266,17 +266,17 @@ public:
       MOZ_ASSERT(!other || !other->ValueFor(aProperty) ||
                  !block->ValueFor(aProperty),
                  "Property both important and not?");
     }
 #endif
     return block->TryReplaceValue(aProperty, aFromBlock, aChanged);
   }
 
-  bool HasNonImportantValueFor(nsCSSPropertyID aProperty) const {
+  bool HasNonImportantValueFor(nsCSSProperty aProperty) const {
     MOZ_ASSERT(!nsCSSProps::IsShorthand(aProperty), "must be longhand");
     return !!mData->ValueFor(aProperty);
   }
 
   /**
    * Return whether |this| may be modified.
    */
   bool IsMutable() const {
@@ -352,55 +352,55 @@ public:
     }
     return nullptr;
   }
 
 private:
   Declaration& operator=(const Declaration& aCopy) = delete;
   bool operator==(const Declaration& aCopy) const = delete;
 
-  void GetValue(nsCSSPropertyID aProperty, nsAString& aValue,
+  void GetValue(nsCSSProperty aProperty, nsAString& aValue,
                 nsCSSValue::Serialization aValueSerialization) const;
 
   static void AppendImportanceToString(bool aIsImportant, nsAString& aString);
   // return whether there was a value in |aValue| (i.e., it had a non-null unit)
-  bool AppendValueToString(nsCSSPropertyID aProperty, nsAString& aResult) const;
-  bool AppendValueToString(nsCSSPropertyID aProperty, nsAString& aResult,
+  bool AppendValueToString(nsCSSProperty aProperty, nsAString& aResult) const;
+  bool AppendValueToString(nsCSSProperty aProperty, nsAString& aResult,
                            nsCSSValue::Serialization aValueSerialization) const;
   // Helper for ToString with strange semantics regarding aValue.
-  void AppendPropertyAndValueToString(nsCSSPropertyID aProperty,
+  void AppendPropertyAndValueToString(nsCSSProperty aProperty,
                                       nsAutoString& aValue,
                                       nsAString& aResult) const;
   // helper for ToString that serializes a custom property declaration for
   // a variable with the specified name
   void AppendVariableAndValueToString(const nsAString& aName,
                                       nsAString& aResult) const;
 
   void GetImageLayerValue(nsCSSCompressedDataBlock *data,
                           nsAString& aValue,
                           nsCSSValue::Serialization aSerialization,
-                          const nsCSSPropertyID aTable[]) const;
+                          const nsCSSProperty aTable[]) const;
 
   void GetImageLayerPositionValue(nsCSSCompressedDataBlock *data,
                                   nsAString& aValue,
                                   nsCSSValue::Serialization aSerialization,
-                                  const nsCSSPropertyID aTable[]) const;
+                                  const nsCSSProperty aTable[]) const;
 
 public:
   /**
    * Returns the property at the given index in the ordered list of
    * declarations.  For custom properties, eCSSPropertyExtra_variable
    * is returned.
    */
-  nsCSSPropertyID GetPropertyAt(uint32_t aIndex) const {
+  nsCSSProperty GetPropertyAt(uint32_t aIndex) const {
     uint32_t value = mOrder[aIndex];
     if (value >= eCSSProperty_COUNT) {
       return eCSSPropertyExtra_variable;
     }
-    return nsCSSPropertyID(value);
+    return nsCSSProperty(value);
   }
 
   /**
    * Gets the name of the custom property at the given index in the ordered
    * list of declarations.
    */
   void GetCustomPropertyNameAt(uint32_t aIndex, nsAString& aResult) const {
     MOZ_ASSERT(mOrder[aIndex] >= eCSSProperty_COUNT);
@@ -409,17 +409,17 @@ public:
     aResult.AppendLiteral("--");
     aResult.Append(mVariableOrder[variableIndex]);
   }
 
   size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
 
 private:
   // The order of properties in this declaration.  Longhand properties are
-  // represented by their nsCSSPropertyID value, and each custom property (--*)
+  // represented by their nsCSSProperty value, and each custom property (--*)
   // is represented by a value that begins at eCSSProperty_COUNT.
   //
   // Subtracting eCSSProperty_COUNT from those values that represent custom
   // properties results in an index into mVariableOrder, which identifies the
   // specific variable the custom property declaration is for.
   AutoTArray<uint32_t, 8> mOrder;
 
   // variable names of custom properties found in mOrder
--- a/layout/style/FontFace.cpp
+++ b/layout/style/FontFace.cpp
@@ -592,17 +592,17 @@ FontFace::GetDesc(nsCSSFontDesc aDescID,
     mRule->GetDesc(aDescID, aResult);
   } else {
     aResult = mDescriptors->Get(aDescID);
   }
 }
 
 void
 FontFace::GetDesc(nsCSSFontDesc aDescID,
-                  nsCSSPropertyID aPropID,
+                  nsCSSProperty aPropID,
                   nsString& aResult) const
 {
   MOZ_ASSERT(aDescID == eCSSFontDesc_UnicodeRange ||
              aDescID == eCSSFontDesc_Display ||
              aPropID != eCSSProperty_UNKNOWN,
              "only pass eCSSProperty_UNKNOWN for eCSSFontDesc_UnicodeRange");
 
   nsCSSValue value;
--- a/layout/style/FontFace.h
+++ b/layout/style/FontFace.h
@@ -4,17 +4,17 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef mozilla_dom_FontFace_h
 #define mozilla_dom_FontFace_h
 
 #include "mozilla/dom/FontFaceBinding.h"
 #include "gfxUserFontSet.h"
 #include "nsAutoPtr.h"
-#include "nsCSSPropertyID.h"
+#include "nsCSSProperty.h"
 #include "nsCSSValue.h"
 #include "nsWrapperCache.h"
 
 class gfxFontFaceBufferSource;
 class nsCSSFontFaceRule;
 
 namespace mozilla {
 struct CSSFontFaceDescriptors;
@@ -186,17 +186,17 @@ private:
                       const FontFaceDescriptors& aDescriptors);
 
   /**
    * Sets the current loading status.
    */
   void SetStatus(mozilla::dom::FontFaceLoadStatus aStatus);
 
   void GetDesc(nsCSSFontDesc aDescID,
-               nsCSSPropertyID aPropID,
+               nsCSSProperty aPropID,
                nsString& aResult) const;
 
   /**
    * Returns and takes ownership of the buffer storing the font data.
    */
   void TakeBuffer(uint8_t*& aBuffer, uint32_t& aLength);
 
   nsCOMPtr<nsISupports> mParent;
--- a/layout/style/GenerateCSSPropsGenerated.py
+++ b/layout/style/GenerateCSSPropsGenerated.py
@@ -15,17 +15,17 @@ def get_properties(preprocessorHeader):
     cpp.append(preprocessorHeader)
     preprocessed = subprocess.check_output(cpp)
     properties = [{"name":p[0], "prop":p[1], "id":p[2],
                    "flags":p[3], "pref":p[4], "proptype":p[5]}
                   for (i, p) in enumerate(eval(preprocessed))]
 
     # Sort the list so that longhand and logical properties are intermingled
     # first, shorthand properties follow, then aliases appear last.  This matches
-    # the order of the nsCSSPropertyID enum.
+    # the order of the nsCSSProperty enum.
 
     def property_compare(x, y):
         property_order = {"longhand": 0, "logical": 0, "shorthand": 1, "alias": 2}
         return property_order[x["proptype"]] - property_order[y["proptype"]]
 
     properties = sorted(properties, cmp=property_compare)
 
     for i, p in enumerate(properties):
@@ -56,30 +56,30 @@ def generate_idl_names(properties):
 
 def generate_assertions(properties):
     def enum(p):
         if p["proptype"] is "alias":
             return "eCSSPropertyAlias_%s" % p["prop"]
         else:
             return "eCSSProperty_%s" % p["id"]
     msg = ('static_assert(%s == %d, "GenerateCSSPropsGenerated.py did not list '
-           'properties in nsCSSPropertyID order");')
+           'properties in nsCSSProperty order");')
     return "\n".join(map(lambda p: msg % (enum(p), p["index"]), properties))
 
 def generate_idl_name_positions(properties):
     # Skip aliases.
     ps = filter(lambda p: p["proptype"] is not "alias", properties)
 
     # Sort alphabetically by IDL name.
     ps = sorted(ps, key=lambda p: p["idlname"])
 
     # Annotate entries with the sorted position.
     ps = [(p, position) for position, p in enumerate(ps)]
 
-    # Sort back to nsCSSPropertyID order.
+    # Sort back to nsCSSProperty order.
     ps = sorted(ps, key=lambda (p, position): p["index"])
 
     return ",\n".join(map(lambda (p, position): "  %d" % position, ps))
 
 def generate(output, cppTemplate, preprocessorHeader):
     cppFile = open(cppTemplate, "r")
     cppTemplate = cppFile.read()
     cppFile.close()
--- a/layout/style/LayerAnimationInfo.cpp
+++ b/layout/style/LayerAnimationInfo.cpp
@@ -25,19 +25,19 @@ LayerAnimationInfo::Initialize()
     MOZ_ASSERT(nsCSSProps::PropHasFlags(record.mProperty,
                                         CSS_PROPERTY_CAN_ANIMATE_ON_COMPOSITOR),
                "CSS property with entry in LayerAnimation::sRecords does not "
                "have the CSS_PROPERTY_CAN_ANIMATE_ON_COMPOSITOR flag");
   }
 
   // Check that every property with the flag for animating on the
   // compositor has an entry in LayerAnimationInfo::sRecords.
-  for (nsCSSPropertyID prop = nsCSSPropertyID(0);
+  for (nsCSSProperty prop = nsCSSProperty(0);
        prop < eCSSProperty_COUNT;
-       prop = nsCSSPropertyID(prop + 1)) {
+       prop = nsCSSProperty(prop + 1)) {
     if (nsCSSProps::PropHasFlags(prop,
                                  CSS_PROPERTY_CAN_ANIMATE_ON_COMPOSITOR)) {
       bool found = false;
       for (const Record& record : sRecords) {
         if (record.mProperty == prop) {
           found = true;
           break;
         }
--- a/layout/style/LayerAnimationInfo.h
+++ b/layout/style/LayerAnimationInfo.h
@@ -2,29 +2,29 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef mozilla_LayerAnimationInfo_h
 #define mozilla_LayerAnimationInfo_h
 
 #include "nsChangeHint.h"
-#include "nsCSSPropertyID.h"
+#include "nsCSSProperty.h"
 #include "nsDisplayList.h" // For nsDisplayItem::Type
 
 namespace mozilla {
 
 struct LayerAnimationInfo {
 #ifdef DEBUG
   static void Initialize();
 #endif
   // For CSS properties that may be animated on a separate layer, represents
   // a record of the corresponding layer type and change hint.
   struct Record {
-    nsCSSPropertyID mProperty;
+    nsCSSProperty mProperty;
     nsDisplayItem::Type mLayerType;
     nsChangeHint mChangeHint;
   };
 
   static const size_t kRecords = 2;
   static const Record sRecords[kRecords];
 };
 
--- a/layout/style/StyleAnimationValue.cpp
+++ b/layout/style/StyleAnimationValue.cpp
@@ -48,17 +48,17 @@ using namespace mozilla::gfx;
  *
  * @param   aFirstUnit One unit to resolve.
  * @param   aFirstUnit The other unit to resolve.
  * @return  A "common" unit that both source units can be converted into, or
  *          eUnit_Null if that's not possible.
  */
 static
 StyleAnimationValue::Unit
-GetCommonUnit(nsCSSPropertyID aProperty,
+GetCommonUnit(nsCSSProperty aProperty,
               StyleAnimationValue::Unit aFirstUnit,
               StyleAnimationValue::Unit aSecondUnit)
 {
   if (aFirstUnit != aSecondUnit) {
     if (nsCSSProps::PropHasFlags(aProperty, CSS_PROPERTY_STORES_CALC) &&
         (aFirstUnit == StyleAnimationValue::eUnit_Coord ||
          aFirstUnit == StyleAnimationValue::eUnit_Percent ||
          aFirstUnit == StyleAnimationValue::eUnit_Calc) &&
@@ -70,17 +70,17 @@ GetCommonUnit(nsCSSPropertyID aProperty,
     }
     return StyleAnimationValue::eUnit_Null;
   }
   return aFirstUnit;
 }
 
 static
 nsCSSUnit
-GetCommonUnit(nsCSSPropertyID aProperty,
+GetCommonUnit(nsCSSProperty aProperty,
               nsCSSUnit aFirstUnit,
               nsCSSUnit aSecondUnit)
 {
   if (aFirstUnit != aSecondUnit) {
     if (nsCSSProps::PropHasFlags(aProperty, CSS_PROPERTY_STORES_CALC) &&
         (aFirstUnit == eCSSUnit_Pixel ||
          aFirstUnit == eCSSUnit_Percent ||
          aFirstUnit == eCSSUnit_Calc) &&
@@ -478,17 +478,17 @@ CalcPositionCoordSquareDistance(const ns
   float diffpct = calcVal2.mPercent - calcVal1.mPercent;
   return difflen * difflen + diffpct * diffpct;
 }
 
 // CLASS METHODS
 // -------------
 
 bool
-StyleAnimationValue::ComputeDistance(nsCSSPropertyID aProperty,
+StyleAnimationValue::ComputeDistance(nsCSSProperty aProperty,
                                      const StyleAnimationValue& aStartValue,
                                      const StyleAnimationValue& aEndValue,
                                      double& aDistance)
 {
   Unit commonUnit =
     GetCommonUnit(aProperty, aStartValue.GetUnit(), aEndValue.GetUnit());
 
   switch (commonUnit) {
@@ -1013,17 +1013,17 @@ RestrictValue(uint32_t aRestrictions, T 
       MOZ_ASSERT(false, "bad value restriction");
       break;
   }
   return result;
 }
 
 template <typename T>
 T
-RestrictValue(nsCSSPropertyID aProperty, T aValue)
+RestrictValue(nsCSSProperty aProperty, T aValue)
 {
   return RestrictValue(nsCSSProps::ValueRestrictions(aProperty), aValue);
 }
 
 static inline void
 AddCSSValuePixel(double aCoeff1, const nsCSSValue &aValue1,
                  double aCoeff2, const nsCSSValue &aValue2,
                  nsCSSValue &aResult, uint32_t aValueRestrictions = 0)
@@ -1835,17 +1835,17 @@ AddPositions(double aCoeff1, const nsCSS
     const nsCSSValue& v2 = posArray2->Item(i);
     nsCSSValue& vr = resultPosArray->Item(i);
     AddCSSValueCanonicalCalc(aCoeff1, v1,
                              aCoeff2, v2, vr);
   }
 }
 
 static Maybe<nsCSSValuePair>
-AddCSSValuePair(nsCSSPropertyID aProperty, uint32_t aRestrictions,
+AddCSSValuePair(nsCSSProperty aProperty, uint32_t aRestrictions,
                 double aCoeff1, const nsCSSValuePair* aPair1,
                 double aCoeff2, const nsCSSValuePair* aPair2)
 {
   MOZ_ASSERT(aPair1, "expected pair");
   MOZ_ASSERT(aPair2, "expected pair");
 
   Maybe<nsCSSValuePair> result;
   nsCSSUnit unit[2];
@@ -1874,17 +1874,17 @@ AddCSSValuePair(nsCSSPropertyID aPropert
       return result; // Nothing() (returning |result| for RVO)
     }
   }
 
   return result;
 }
 
 static UniquePtr<nsCSSValuePairList>
-AddCSSValuePairList(nsCSSPropertyID aProperty,
+AddCSSValuePairList(nsCSSProperty aProperty,
                     double aCoeff1, const nsCSSValuePairList* aList1,
                     double aCoeff2, const nsCSSValuePairList* aList2)
 {
   MOZ_ASSERT(aList1, "Can't add a null list");
   MOZ_ASSERT(aList2, "Can't add a null list");
 
   auto result = MakeUnique<nsCSSValuePairList>();
   nsCSSValuePairList* resultPtr = result.get();
@@ -1926,17 +1926,17 @@ AddCSSValuePairList(nsCSSPropertyID aPro
   if (aList1 || aList2) {
     return nullptr; // We can't interpolate lists of different lengths
   }
 
   return result;
 }
 
 static already_AddRefed<nsCSSValue::Array>
-AddShapeFunction(nsCSSPropertyID aProperty,
+AddShapeFunction(nsCSSProperty aProperty,
                  double aCoeff1, const nsCSSValue::Array* aArray1,
                  double aCoeff2, const nsCSSValue::Array* aArray2)
 {
   MOZ_ASSERT(aArray1 && aArray1->Count() == 2, "expected shape function");
   MOZ_ASSERT(aArray2 && aArray2->Count() == 2, "expected shape function");
   MOZ_ASSERT(aArray1->Item(0).GetUnit() == eCSSUnit_Function,
              "expected function");
   MOZ_ASSERT(aArray2->Item(0).GetUnit() == eCSSUnit_Function,
@@ -2243,17 +2243,17 @@ AddPositionCoords(double aCoeff1, const 
   const nsCSSValue& v1 = posArray1->Item(1);
   const nsCSSValue& v2 = posArray2->Item(1);
   nsCSSValue& vr = resultPosArray->Item(1);
   AddCSSValueCanonicalCalc(aCoeff1, v1,
                            aCoeff2, v2, vr);
 }
 
 bool
-StyleAnimationValue::AddWeighted(nsCSSPropertyID aProperty,
+StyleAnimationValue::AddWeighted(nsCSSProperty aProperty,
                                  double aCoeff1,
                                  const StyleAnimationValue& aValue1,
                                  double aCoeff2,
                                  const StyleAnimationValue& aValue2,
                                  StyleAnimationValue& aResultValue)
 {
   Unit commonUnit =
     GetCommonUnit(aProperty, aValue1.GetUnit(), aValue2.GetUnit());
@@ -2753,31 +2753,31 @@ StyleAnimationValue::AddWeighted(nsCSSPr
     }
   }
 
   MOZ_ASSERT(false, "Can't interpolate using the given common unit");
   return false;
 }
 
 already_AddRefed<css::StyleRule>
-BuildStyleRule(nsCSSPropertyID aProperty,
+BuildStyleRule(nsCSSProperty aProperty,
                dom::Element* aTargetElement,
                const nsAString& aSpecifiedValue,
                bool aUseSVGMode)
 {
   // Set up an empty CSS Declaration
   RefPtr<css::Declaration> declaration(new css::Declaration());
   declaration->InitializeEmpty();
 
   bool changed; // ignored, but needed as outparam for ParseProperty
   nsIDocument* doc = aTargetElement->OwnerDoc();
   nsCOMPtr<nsIURI> baseURI = aTargetElement->GetBaseURI();
   nsCSSParser parser(doc->CSSLoader());
 
-  nsCSSPropertyID propertyToCheck = nsCSSProps::IsShorthand(aProperty) ?
+  nsCSSProperty propertyToCheck = nsCSSProps::IsShorthand(aProperty) ?
     nsCSSProps::SubpropertyEntryFor(aProperty)[0] : aProperty;
 
   // Get a parser, parse the property, and check for CSS parsing errors.
   // If this fails, we bail out and delete the declaration.
   parser.ParseProperty(aProperty, aSpecifiedValue, doc->GetDocumentURI(),
                        baseURI, aTargetElement->NodePrincipal(), declaration,
                        &changed, false, aUseSVGMode);
 
@@ -2788,17 +2788,17 @@ BuildStyleRule(nsCSSPropertyID aProperty
 
   RefPtr<css::StyleRule> rule = new css::StyleRule(nullptr,
                                                      declaration,
                                                      0, 0);
   return rule.forget();
 }
 
 already_AddRefed<css::StyleRule>
-BuildStyleRule(nsCSSPropertyID aProperty,
+BuildStyleRule(nsCSSProperty aProperty,
                dom::Element* aTargetElement,
                const nsCSSValue& aSpecifiedValue,
                bool aUseSVGMode)
 {
   MOZ_ASSERT(!nsCSSProps::IsShorthand(aProperty),
              "Should be a longhand property");
 
   // Check if longhand failed to parse correctly.
@@ -2817,17 +2817,17 @@ BuildStyleRule(nsCSSPropertyID aProperty
   declaration->ValueAppended(aProperty);
   declaration->CompressFrom(&block);
 
   RefPtr<css::StyleRule> rule = new css::StyleRule(nullptr, declaration, 0, 0);
   return rule.forget();
 }
 
 static bool
-ComputeValuesFromStyleRule(nsCSSPropertyID aProperty,
+ComputeValuesFromStyleRule(nsCSSProperty aProperty,
                            CSSEnabledState aEnabledState,
                            dom::Element* aTargetElement,
                            nsStyleContext* aStyleContext,
                            css::StyleRule* aStyleRule,
                            nsTArray<PropertyStyleAnimationValuePair>& aValues,
                            bool* aIsContextSensitive)
 {
   MOZ_ASSERT(aStyleContext);
@@ -2905,17 +2905,17 @@ ComputeValuesFromStyleRule(nsCSSProperty
     PropertyStyleAnimationValuePair* pair = aValues.AppendElement();
     pair->mProperty = aProperty;
     return StyleAnimationValue::ExtractComputedValue(aProperty, tmpStyleContext,
                                                      pair->mValue);
   }
 }
 
 /* static */ bool
-StyleAnimationValue::ComputeValue(nsCSSPropertyID aProperty,
+StyleAnimationValue::ComputeValue(nsCSSProperty aProperty,
                                   dom::Element* aTargetElement,
                                   nsStyleContext* aStyleContext,
                                   const nsAString& aSpecifiedValue,
                                   bool aUseSVGMode,
                                   StyleAnimationValue& aComputedValue,
                                   bool* aIsContextSensitive)
 {
   MOZ_ASSERT(aTargetElement, "null target element");
@@ -2956,17 +2956,17 @@ StyleAnimationValue::ComputeValue(nsCSSP
 
   aComputedValue = values[0].mValue;
   return true;
 }
 
 template <class T>
 bool
 ComputeValuesFromSpecifiedValue(
-    nsCSSPropertyID aProperty,
+    nsCSSProperty aProperty,
     CSSEnabledState aEnabledState,
     dom::Element* aTargetElement,
     nsStyleContext* aStyleContext,
     T& aSpecifiedValue,
     bool aUseSVGMode,
     nsTArray<PropertyStyleAnimationValuePair>& aResult)
 {
   MOZ_ASSERT(aTargetElement, "null target element");
@@ -2984,48 +2984,48 @@ ComputeValuesFromSpecifiedValue(
   aResult.Clear();
   return ComputeValuesFromStyleRule(aProperty, aEnabledState, aTargetElement,
                                     aStyleContext, styleRule, aResult,
                                     /* aIsContextSensitive */ nullptr);
 }
 
 /* static */ bool
 StyleAnimationValue::ComputeValues(
-    nsCSSPropertyID aProperty,
+    nsCSSProperty aProperty,
     CSSEnabledState aEnabledState,
     dom::Element* aTargetElement,
     nsStyleContext* aStyleContext,
     const nsAString& aSpecifiedValue,
     bool aUseSVGMode,
     nsTArray<PropertyStyleAnimationValuePair>& aResult)
 {
   return ComputeValuesFromSpecifiedValue(aProperty, aEnabledState,
                                          aTargetElement, aStyleContext,
                                          aSpecifiedValue, aUseSVGMode,
                                          aResult);
 }
 
 /* static */ bool
 StyleAnimationValue::ComputeValues(
-    nsCSSPropertyID aProperty,
+    nsCSSProperty aProperty,
     CSSEnabledState aEnabledState,
     dom::Element* aTargetElement,
     nsStyleContext* aStyleContext,
     const nsCSSValue& aSpecifiedValue,
     bool aUseSVGMode,
     nsTArray<PropertyStyleAnimationValuePair>& aResult)
 {
   return ComputeValuesFromSpecifiedValue(aProperty, aEnabledState,
                                          aTargetElement, aStyleContext,
                                          aSpecifiedValue, aUseSVGMode,
                                          aResult);
 }
 
 bool
-StyleAnimationValue::UncomputeValue(nsCSSPropertyID aProperty,
+StyleAnimationValue::UncomputeValue(nsCSSProperty aProperty,
                                     const StyleAnimationValue& aComputedValue,
                                     nsCSSValue& aSpecifiedValue)
 {
   Unit unit = aComputedValue.GetUnit();
   switch (unit) {
     case eUnit_Normal:
       aSpecifiedValue.SetNormalValue();
       break;
@@ -3133,17 +3133,17 @@ StyleAnimationValue::UncomputeValue(nsCS
       break;
     default:
       return false;
   }
   return true;
 }
 
 bool
-StyleAnimationValue::UncomputeValue(nsCSSPropertyID aProperty,
+StyleAnimationValue::UncomputeValue(nsCSSProperty aProperty,
                                     StyleAnimationValue&& aComputedValue,
                                     nsCSSValue& aSpecifiedValue)
 {
   Unit unit = aComputedValue.GetUnit();
   switch (unit) {
     case eUnit_Dasharray:
     case eUnit_Shadow:
     case eUnit_Filter:
@@ -3168,17 +3168,17 @@ StyleAnimationValue::UncomputeValue(nsCS
       break;
     default:
       return UncomputeValue(aProperty, aComputedValue, aSpecifiedValue);
   }
   return true;
 }
 
 bool
-StyleAnimationValue::UncomputeValue(nsCSSPropertyID aProperty,
+StyleAnimationValue::UncomputeValue(nsCSSProperty aProperty,
                                     const StyleAnimationValue& aComputedValue,
                                     nsAString& aSpecifiedValue)
 {
   aSpecifiedValue.Truncate(); // Clear outparam, if it's not already empty
 
   if (aComputedValue.GetUnit() == eUnit_UnparsedString) {
     aComputedValue.GetStringValue(aSpecifiedValue);
     return true;
@@ -3586,17 +3586,17 @@ StyleClipBasicShapeToCSSArray(const Styl
       return false;
   }
   aResult->Item(1).SetIntValue(aClipPath.GetReferenceBox(),
                                eCSSUnit_Enumerated);
   return true;
 }
 
 bool
-StyleAnimationValue::ExtractComputedValue(nsCSSPropertyID aProperty,
+StyleAnimationValue::ExtractComputedValue(nsCSSProperty aProperty,
                                           nsStyleContext* aStyleContext,
                                           StyleAnimationValue& aComputedValue)
 {
   MOZ_ASSERT(0 <= aProperty && aProperty < eCSSProperty_COUNT_no_shorthands,
              "bad property");
   const void* styleStruct =
     aStyleContext->StyleData(nsCSSProps::kSIDTable[aProperty]);
   ptrdiff_t ssOffset = nsCSSProps::kStyleStructOffsetTable[aProperty];
--- a/layout/style/StyleAnimationValue.h
+++ b/layout/style/StyleAnimationValue.h
@@ -48,17 +48,17 @@ public:
    * Note that if |aCount| is 0, then |aDest| will be unchanged.  Also, if
    * this method fails, then |aDest| will be unchanged.
    *
    * @param aDest       The value to add to.
    * @param aValueToAdd The value to add.
    * @param aCount      The number of times to add aValueToAdd.
    * @return true on success, false on failure.
    */
-  static bool Add(nsCSSPropertyID aProperty, StyleAnimationValue& aDest,
+  static bool Add(nsCSSProperty aProperty, StyleAnimationValue& aDest,
                   const StyleAnimationValue& aValueToAdd, uint32_t aCount) {
     return AddWeighted(aProperty, 1.0, aDest, aCount, aValueToAdd, aDest);
   }
 
   /**
    * Calculates a measure of 'distance' between two values.
    *
    * This measure of Distance is guaranteed to be proportional to
@@ -71,17 +71,17 @@ public:
    *
    * @param aStartValue The start of the interval for which the distance
    *                    should be calculated.
    * @param aEndValue   The end of the interval for which the distance
    *                    should be calculated.
    * @param aDistance   The result of the calculation.
    * @return true on success, false on failure.
    */
-  static bool ComputeDistance(nsCSSPropertyID aProperty,
+  static bool ComputeDistance(nsCSSProperty aProperty,
                               const StyleAnimationValue& aStartValue,
                               const StyleAnimationValue& aEndValue,
                               double& aDistance);
 
   /**
    * Calculates an interpolated value that is the specified |aPortion| between
    * the two given values.
    *
@@ -92,17 +92,17 @@ public:
    *                    interpolation.
    * @param aEndValue   The value defining the end of the interval of
    *                    interpolation.
    * @param aPortion    A number in the range [0.0, 1.0] defining the
    *                    distance of the interpolated value in the interval.
    * @param [out] aResultValue The resulting interpolated value.
    * @return true on success, false on failure.
    */
-  static bool Interpolate(nsCSSPropertyID aProperty,
+  static bool Interpolate(nsCSSProperty aProperty,
                           const StyleAnimationValue& aStartValue,
                           const StyleAnimationValue& aEndValue,
                           double aPortion,
                           StyleAnimationValue& aResultValue) {
     return AddWeighted(aProperty, 1.0 - aPortion, aStartValue,
                        aPortion, aEndValue, aResultValue);
   }
 
@@ -115,17 +115,17 @@ public:
    * @return true on success, false on failure.
    *
    * NOTE: Current callers always pass aCoeff1 and aCoeff2 >= 0.  They
    * are currently permitted to be negative; however, if, as we add
    * support more value types types, we find that this causes
    * difficulty, we might change this to restrict them to being
    * positive.
    */
-  static bool AddWeighted(nsCSSPropertyID aProperty,
+  static bool AddWeighted(nsCSSProperty aProperty,
                           double aCoeff1, const StyleAnimationValue& aValue1,
                           double aCoeff2, const StyleAnimationValue& aValue2,
                           StyleAnimationValue& aResultValue);
 
   // Type-conversion methods
   // -----------------------
   /**
    * Creates a computed value for the given specified value
@@ -152,17 +152,17 @@ public:
    *                        a different |aComputedValue| depending on other CSS
    *                        properties on |aTargetElement| or its ancestors.
    *                        false otherwise.
    *                        Note that the operation of this method is
    *                        significantly faster when |aIsContextSensitive| is
    *                        nullptr.
    * @return true on success, false on failure.
    */
-  static bool ComputeValue(nsCSSPropertyID aProperty,
+  static bool ComputeValue(nsCSSProperty aProperty,
                            mozilla::dom::Element* aTargetElement,
                            nsStyleContext* aStyleContext,
                            const nsAString& aSpecifiedValue,
                            bool aUseSVGMode,
                            StyleAnimationValue& aComputedValue,
                            bool* aIsContextSensitive = nullptr);
 
   /**
@@ -170,29 +170,29 @@ public:
    *
    * On success, when aProperty is a longhand, aResult will have a single
    * value in it.  When aProperty is a shorthand, aResult will be filled with
    * values for all of aProperty's longhand components.  aEnabledState
    * is used to filter the longhand components that will be appended
    * to aResult.  On failure, aResult might still have partial results
    * in it.
    */
-  static bool ComputeValues(nsCSSPropertyID aProperty,
+  static bool ComputeValues(nsCSSProperty aProperty,
                             mozilla::CSSEnabledState aEnabledState,
                             mozilla::dom::Element* aTargetElement,
                             nsStyleContext* aStyleContext,
                             const nsAString& aSpecifiedValue,
                             bool aUseSVGMode,
                             nsTArray<PropertyStyleAnimationValuePair>& aResult);
 
   /**
    * A variant on ComputeValues that takes an nsCSSValue as the specified
    * value. Only longhand properties are supported.
    */
-  static bool ComputeValues(nsCSSPropertyID aProperty,
+  static bool ComputeValues(nsCSSProperty aProperty,
                             mozilla::CSSEnabledState aEnabledState,
                             mozilla::dom::Element* aTargetElement,
                             nsStyleContext* aStyleContext,
                             const nsCSSValue& aSpecifiedValue,
                             bool aUseSVGMode,
                             nsTArray<PropertyStyleAnimationValuePair>& aResult);
 
   /**
@@ -207,23 +207,23 @@ public:
    * transfers ownership for some resources such that the |aComputedValue|
    * does not depend on the lifetime of |aSpecifiedValue|.
    *
    * @param aProperty      The property whose value we're uncomputing.
    * @param aComputedValue The computed value to be converted.
    * @param [out] aSpecifiedValue The resulting specified value.
    * @return true on success, false on failure.
    */
-  static bool UncomputeValue(nsCSSPropertyID aProperty,
+  static bool UncomputeValue(nsCSSProperty aProperty,
                              const StyleAnimationValue& aComputedValue,
                              nsCSSValue& aSpecifiedValue);
-  static bool UncomputeValue(nsCSSPropertyID aProperty,
+  static bool UncomputeValue(nsCSSProperty aProperty,
                              StyleAnimationValue&& aComputedValue,
                              nsCSSValue& aSpecifiedValue);
-  static bool UncomputeValue(nsCSSPropertyID aProperty,
+  static bool UncomputeValue(nsCSSProperty aProperty,
                              const StyleAnimationValue& aComputedValue,
                              nsAString& aSpecifiedValue);
 
   /**
    * Gets the computed value for the given property from the given style
    * context.
    *
    * Obtaining the computed value allows us to animate properties when the
@@ -231,17 +231,17 @@ public:
    * other keyword that isn't directly interpolatable, but which *computes* to
    * something interpolatable.
    *
    * @param aProperty     The property whose value we're looking up.
    * @param aStyleContext The style context to check for the computed value.
    * @param [out] aComputedValue The resulting computed value.
    * @return true on success, false on failure.
    */
-  static bool ExtractComputedValue(nsCSSPropertyID aProperty,
+  static bool ExtractComputedValue(nsCSSProperty aProperty,
                                    nsStyleContext* aStyleContext,
                                    StyleAnimationValue& aComputedValue);
 
   /**
    * Interpolates between 2 matrices by decomposing them.
    *
    * @param aMatrix1   First matrix, using CSS pixel units.
    * @param aMatrix2   Second matrix, using CSS pixel units.
@@ -506,15 +506,15 @@ private:
   }
   static bool IsStringUnit(Unit aUnit) {
     return aUnit == eUnit_UnparsedString;
   }
 };
 
 struct PropertyStyleAnimationValuePair
 {
-  nsCSSPropertyID mProperty;
+  nsCSSProperty mProperty;
   StyleAnimationValue mValue;
 };
 
 } // namespace mozilla
 
 #endif
--- a/layout/style/moz.build
+++ b/layout/style/moz.build
@@ -37,18 +37,18 @@ EXPORTS += [
     'nsCSSAnonBoxes.h',
     'nsCSSAnonBoxList.h',
     'nsCSSCounterDescList.h',
     'nsCSSFontDescList.h',
     'nsCSSKeywordList.h',
     'nsCSSKeywords.h',
     'nsCSSParser.h',
     'nsCSSPropAliasList.h',
-    'nsCSSPropertyID.h',
-    'nsCSSPropertyIDSet.h',
+    'nsCSSProperty.h',
+    'nsCSSPropertySet.h',
     'nsCSSPropList.h',
     'nsCSSPropLogicalGroupList.h',
     'nsCSSProps.h',
     'nsCSSPseudoClasses.h',
     'nsCSSPseudoClassList.h',
     'nsCSSPseudoElementList.h',
     'nsCSSPseudoElements.h',
     'nsCSSRuleProcessor.h',
--- a/layout/style/nsAnimationManager.cpp
+++ b/layout/style/nsAnimationManager.cpp
@@ -544,29 +544,29 @@ private:
                                           const nsCSSKeyframesRule* aRule);
   Maybe<ComputedTimingFunction> GetKeyframeTimingFunction(
     nsPresContext* aPresContext,
     nsCSSKeyframeRule* aKeyframeRule,
     const Maybe<ComputedTimingFunction>& aInheritedTimingFunction);
   nsTArray<PropertyValuePair> GetKeyframePropertyValues(
     nsPresContext* aPresContext,
     nsCSSKeyframeRule* aKeyframeRule,
-    nsCSSPropertyIDSet& aAnimatedProperties);
+    nsCSSPropertySet& aAnimatedProperties);
   void FillInMissingKeyframeValues(
     nsPresContext* aPresContext,
-    nsCSSPropertyIDSet aAnimatedProperties,
-    nsCSSPropertyIDSet aPropertiesSetAtStart,
-    nsCSSPropertyIDSet aPropertiesSetAtEnd,
+    nsCSSPropertySet aAnimatedProperties,
+    nsCSSPropertySet aPropertiesSetAtStart,
+    nsCSSPropertySet aPropertiesSetAtEnd,
     const Maybe<ComputedTimingFunction>& aInheritedTimingFunction,
     nsTArray<Keyframe>& aKeyframes);
   void AppendProperty(nsPresContext* aPresContext,
-                      nsCSSPropertyID aProperty,
+                      nsCSSProperty aProperty,
                       nsTArray<PropertyValuePair>& aPropertyValues);
   nsCSSValue GetComputedValue(nsPresContext* aPresContext,
-                              nsCSSPropertyID aProperty);
+                              nsCSSProperty aProperty);
 
   static TimingParams TimingParamsFrom(
     const StyleAnimation& aStyleAnimation)
   {
     TimingParams timing;
 
     timing.mDuration.emplace(StickyTimeDuration::FromMilliseconds(
                                aStyleAnimation.GetDuration()));
@@ -712,17 +712,17 @@ CSSAnimationBuilder::BuildAnimationFrame
   // FIXME: There is a pending spec change to make multiple @keyframes
   // rules with the same name cascade but we don't support that yet.
 
   Maybe<ComputedTimingFunction> inheritedTimingFunction =
     ConvertTimingFunction(aSrc.GetTimingFunction());
 
   // First, make up Keyframe objects for each rule
   nsTArray<Keyframe> keyframes;
-  nsCSSPropertyIDSet animatedProperties;
+  nsCSSPropertySet animatedProperties;
 
   for (auto ruleIdx = 0, ruleEnd = aRule->StyleRuleCount();
        ruleIdx != ruleEnd; ++ruleIdx) {
     css::Rule* cssRule = aRule->GetStyleRuleAt(ruleIdx);
     MOZ_ASSERT(cssRule, "must have rule");
     MOZ_ASSERT(cssRule->GetType() == css::Rule::KEYFRAME_RULE,
                "must be keyframe rule");
     nsCSSKeyframeRule* keyframeRule = static_cast<nsCSSKeyframeRule*>(cssRule);
@@ -749,19 +749,19 @@ CSSAnimationBuilder::BuildAnimationFrame
   // Next, stable sort by offset
   std::stable_sort(keyframes.begin(), keyframes.end(),
                    [](const Keyframe& a, const Keyframe& b)
                    {
                      return a.mOffset < b.mOffset;
                    });
 
   // Then walk backwards through the keyframes and drop overridden properties.
-  nsCSSPropertyIDSet propertiesSetAtCurrentOffset;
-  nsCSSPropertyIDSet propertiesSetAtStart;
-  nsCSSPropertyIDSet propertiesSetAtEnd;
+  nsCSSPropertySet propertiesSetAtCurrentOffset;
+  nsCSSPropertySet propertiesSetAtStart;
+  nsCSSPropertySet propertiesSetAtEnd;
   double currentOffset = -1.0;
   for (size_t keyframeIdx = keyframes.Length();
        keyframeIdx > 0;
        --keyframeIdx) {
     Keyframe& keyframe = keyframes[keyframeIdx - 1];
     MOZ_ASSERT(keyframe.mOffset, "Should have filled in the offset");
 
     if (keyframe.mOffset.value() != currentOffset) {
@@ -869,26 +869,26 @@ ConvertTimingFunction(const nsTimingFunc
 
   return result;
 }
 
 nsTArray<PropertyValuePair>
 CSSAnimationBuilder::GetKeyframePropertyValues(
     nsPresContext* aPresContext,
     nsCSSKeyframeRule* aKeyframeRule,
-    nsCSSPropertyIDSet& aAnimatedProperties)
+    nsCSSPropertySet& aAnimatedProperties)
 {
   nsTArray<PropertyValuePair> result;
   RefPtr<nsStyleContext> styleContext =
     mResolvedStyles.Get(aPresContext, mStyleContext,
                         aKeyframeRule->Declaration());
 
-  for (nsCSSPropertyID prop = nsCSSPropertyID(0);
+  for (nsCSSProperty prop = nsCSSProperty(0);
        prop < eCSSProperty_COUNT_no_shorthands;
-       prop = nsCSSPropertyID(prop + 1)) {
+       prop = nsCSSProperty(prop + 1)) {
     if (nsCSSProps::kAnimTypeTable[prop] == eStyleAnimType_None ||
         !aKeyframeRule->Declaration()->HasNonImportantValueFor(prop)) {
       continue;
     }
 
     PropertyValuePair pair;
     pair.mProperty = prop;
 
@@ -944,19 +944,19 @@ FindMatchingKeyframe(
     ++aIndex;
   }
   return false;
 }
 
 void
 CSSAnimationBuilder::FillInMissingKeyframeValues(
     nsPresContext* aPresContext,
-    nsCSSPropertyIDSet aAnimatedProperties,
-    nsCSSPropertyIDSet aPropertiesSetAtStart,
-    nsCSSPropertyIDSet aPropertiesSetAtEnd,
+    nsCSSPropertySet aAnimatedProperties,
+    nsCSSPropertySet aPropertiesSetAtStart,
+    nsCSSPropertySet aPropertiesSetAtEnd,
     const Maybe<ComputedTimingFunction>& aInheritedTimingFunction,
     nsTArray<Keyframe>& aKeyframes)
 {
   static const size_t kNotSet = static_cast<size_t>(-1);
 
   // Find/create the keyframe to add start values to
   size_t startKeyframeIndex = kNotSet;
   if (!aAnimatedProperties.Equals(aPropertiesSetAtStart) &&
@@ -992,48 +992,48 @@ CSSAnimationBuilder::FillInMissingKeyfra
   // Now that we have finished manipulating aKeyframes, it is safe to
   // take pointers to its elements.
   Keyframe* startKeyframe = startKeyframeIndex == kNotSet
                             ? nullptr : &aKeyframes[startKeyframeIndex];
   Keyframe* endKeyframe   = endKeyframeIndex == kNotSet
                             ? nullptr : &aKeyframes[endKeyframeIndex];
 
   // Iterate through all properties and fill-in missing values
-  for (nsCSSPropertyID prop = nsCSSPropertyID(0);
+  for (nsCSSProperty prop = nsCSSProperty(0);
        prop < eCSSProperty_COUNT_no_shorthands;
-       prop = nsCSSPropertyID(prop + 1)) {
+       prop = nsCSSProperty(prop + 1)) {
     if (!aAnimatedProperties.HasProperty(prop)) {
       continue;
     }
 
     if (startKeyframe && !aPropertiesSetAtStart.HasProperty(prop)) {
       AppendProperty(aPresContext, prop, startKeyframe->mPropertyValues);
     }
     if (endKeyframe && !aPropertiesSetAtEnd.HasProperty(prop)) {
       AppendProperty(aPresContext, prop, endKeyframe->mPropertyValues);
     }
   }
 }
 
 void
 CSSAnimationBuilder::AppendProperty(
     nsPresContext* aPresContext,
-    nsCSSPropertyID aProperty,
+    nsCSSProperty aProperty,
     nsTArray<PropertyValuePair>& aPropertyValues)
 {
   PropertyValuePair propertyValue;
   propertyValue.mProperty = aProperty;
   propertyValue.mValue = GetComputedValue(aPresContext, aProperty);
 
   aPropertyValues.AppendElement(Move(propertyValue));
 }
 
 nsCSSValue
 CSSAnimationBuilder::GetComputedValue(nsPresContext* aPresContext,
-                                      nsCSSPropertyID aProperty)
+                                      nsCSSProperty aProperty)
 {
   nsCSSValue result;
   StyleAnimationValue computedValue;
 
   if (!mStyleWithoutAnimation) {
     MOZ_ASSERT(aPresContext->StyleSet()->IsGecko(),
                "ServoStyleSet should not use nsAnimationManager for "
                "animations");
--- a/layout/style/nsCSSDataBlock.cpp
+++ b/layout/style/nsCSSDataBlock.cpp
@@ -50,17 +50,17 @@ ShouldIgnoreColors(nsRuleData *aRuleData
 }
 
 /**
  * Tries to call |nsCSSValue::StartImageLoad()| on an image source.
  * Image sources are specified by |url()| or |-moz-image-rect()| function.
  */
 static void
 TryToStartImageLoadOnValue(const nsCSSValue& aValue, nsIDocument* aDocument,
-                           nsStyleContext* aContext, nsCSSPropertyID aProperty,
+                           nsStyleContext* aContext, nsCSSProperty aProperty,
                            bool aForTokenStream)
 {
   MOZ_ASSERT(aDocument);
 
   if (aValue.GetUnit() == eCSSUnit_URL) {
 #ifdef MOZ_ENABLE_MASK_AS_SHORTHAND
     // The 'mask-image' property accepts local reference URIs.
     // For example,
@@ -120,17 +120,17 @@ TryToStartImageLoadOnValue(const nsCSSVa
     const nsCSSValue& image = arguments->Item(1);
     TryToStartImageLoadOnValue(image, aDocument, aContext, aProperty,
                                aForTokenStream);
   }
 }
 
 static void
 TryToStartImageLoad(const nsCSSValue& aValue, nsIDocument* aDocument,
-                    nsStyleContext* aContext, nsCSSPropertyID aProperty,
+                    nsStyleContext* aContext, nsCSSProperty aProperty,
                     bool aForTokenStream)
 {
   if (aValue.GetUnit() == eCSSUnit_List) {
     for (const nsCSSValueList* l = aValue.GetListValue(); l; l = l->mNext) {
       TryToStartImageLoad(l->mValue, aDocument, aContext, aProperty,
                           aForTokenStream);
     }
   } else if (nsCSSProps::PropHasFlags(aProperty,
@@ -141,31 +141,31 @@ TryToStartImageLoad(const nsCSSValue& aV
     }
   } else {
     TryToStartImageLoadOnValue(aValue, aDocument, aContext, aProperty,
                                aForTokenStream);
   }
 }
 
 static inline bool
-ShouldStartImageLoads(nsRuleData *aRuleData, nsCSSPropertyID aProperty)
+ShouldStartImageLoads(nsRuleData *aRuleData, nsCSSProperty aProperty)
 {
   // Don't initiate image loads for if-visited styles.  This is
   // important because:
   //  (1) it's a waste of CPU and bandwidth
   //  (2) in some cases we'd start the image load on a style change
   //      where we wouldn't have started the load initially, which makes
   //      which links are visited detectable to Web pages (see bug
   //      557287)
   return !aRuleData->mStyleContext->IsStyleIfVisited() &&
          nsCSSProps::PropHasFlags(aProperty, CSS_PROPERTY_START_IMAGE_LOADS);
 }
 
 static void
-MapSinglePropertyInto(nsCSSPropertyID aTargetProp,
+MapSinglePropertyInto(nsCSSProperty aTargetProp,
                       const nsCSSValue* aSrcValue,
                       nsCSSValue* aTargetValue,
                       nsRuleData* aRuleData)
 {
   MOZ_ASSERT(!nsCSSProps::PropHasFlags(aTargetProp, CSS_PROPERTY_LOGICAL),
              "Can't map into a logical property");
   MOZ_ASSERT(aSrcValue->GetUnit() != eCSSUnit_Null, "oops");
 
@@ -207,17 +207,17 @@ MapSinglePropertyInto(nsCSSPropertyID aT
 }
 
 /**
  * If aProperty is a logical property, converts it to the equivalent physical
  * property based on writing mode information obtained from aRuleData's
  * style context.
  */
 static inline void
-EnsurePhysicalProperty(nsCSSPropertyID& aProperty, nsRuleData* aRuleData)
+EnsurePhysicalProperty(nsCSSProperty& aProperty, nsRuleData* aRuleData)
 {
   bool isAxisProperty =
     nsCSSProps::PropHasFlags(aProperty, CSS_PROPERTY_LOGICAL_AXIS);
   bool isBlock =
     nsCSSProps::PropHasFlags(aProperty, CSS_PROPERTY_LOGICAL_BLOCK_AXIS);
 
   int index;
 
@@ -253,17 +253,17 @@ EnsurePhysicalProperty(nsCSSPropertyID& 
     // We rely on the physical side constant values matching the order of
     // the physical properties in the logical group array.
     static_assert(NS_SIDE_TOP == 0 && NS_SIDE_RIGHT == 1 &&
                   NS_SIDE_BOTTOM == 2 && NS_SIDE_LEFT == 3,
                   "unexpected side constant values");
     index = side;
   }
 
-  const nsCSSPropertyID* props = nsCSSProps::LogicalGroup(aProperty);
+  const nsCSSProperty* props = nsCSSProps::LogicalGroup(aProperty);
   size_t len = isAxisProperty ? 2 : 4;
 #ifdef DEBUG
     for (size_t i = 0; i < len; i++) {
     MOZ_ASSERT(props[i] != eCSSProperty_UNKNOWN,
                "unexpected logical group length");
   }
   MOZ_ASSERT(props[len] == eCSSProperty_UNKNOWN,
              "unexpected logical group length");
@@ -307,17 +307,17 @@ nsCSSCompressedDataBlock::MapRuleInfoInt
   // the rest of the function.
   if (!(aRuleData->mSIDs & mStyleBits))
     return;
 
   // We process these in reverse order so that we end up mapping the
   // right property when one can be expressed using both logical and
   // physical property names.
   for (uint32_t i = mNumProps; i-- > 0; ) {
-    nsCSSPropertyID iProp = PropertyAtIndex(i);
+    nsCSSProperty iProp = PropertyAtIndex(i);
     if (nsCachedStyleData::GetBitForSID(nsCSSProps::kSIDTable[iProp]) &
         aRuleData->mSIDs) {
       if (nsCSSProps::PropHasFlags(iProp, CSS_PROPERTY_LOGICAL)) {
         EnsurePhysicalProperty(iProp, aRuleData);
       }
       nsCSSValue* target = aRuleData->ValueFor(iProp);
       if (target->GetUnit() == eCSSUnit_Null) {
         const nsCSSValue *val = ValueAtIndex(i);
@@ -332,17 +332,17 @@ nsCSSCompressedDataBlock::MapRuleInfoInt
         }
         MapSinglePropertyInto(iProp, val, target, aRuleData);
       }
     }
   }
 }
 
 const nsCSSValue*
-nsCSSCompressedDataBlock::ValueFor(nsCSSPropertyID aProperty) const
+nsCSSCompressedDataBlock::ValueFor(nsCSSProperty aProperty) const
 {
   MOZ_ASSERT(!nsCSSProps::IsShorthand(aProperty),
              "Don't call for shorthands");
 
   // If we have no data for this struct, then return immediately.
   // This optimization should make us return most of the time, so we
   // have to worry much less (although still some) about the speed of
   // the rest of the function.
@@ -355,17 +355,17 @@ nsCSSCompressedDataBlock::ValueFor(nsCSS
       return ValueAtIndex(i);
     }
   }
 
   return nullptr;
 }
 
 bool
-nsCSSCompressedDataBlock::TryReplaceValue(nsCSSPropertyID aProperty,
+nsCSSCompressedDataBlock::TryReplaceValue(nsCSSProperty aProperty,
                                           nsCSSExpandedDataBlock& aFromBlock,
                                           bool *aChanged)
 {
   nsCSSValue* newValue = aFromBlock.PropertyAt(aProperty);
   MOZ_ASSERT(newValue && newValue->GetUnit() != eCSSUnit_Null,
              "cannot replace with empty value");
 
   const nsCSSValue* oldValue = ValueFor(aProperty);
@@ -475,17 +475,17 @@ void
 nsCSSExpandedDataBlock::DoExpand(nsCSSCompressedDataBlock *aBlock,
                                  bool aImportant)
 {
   /*
    * Save needless copying and allocation by copying the memory
    * corresponding to the stored data in the compressed block.
    */
   for (uint32_t i = 0; i < aBlock->mNumProps; i++) {
-    nsCSSPropertyID iProp = aBlock->PropertyAtIndex(i);
+    nsCSSProperty iProp = aBlock->PropertyAtIndex(i);
     MOZ_ASSERT(!nsCSSProps::IsShorthand(iProp), "out of range");
     MOZ_ASSERT(!HasPropertyBit(iProp),
                "compressed block has property multiple times");
     SetPropertyBit(iProp);
     if (aImportant)
       SetImportantBit(iProp);
 
     const nsCSSValue* val = aBlock->ValueAtIndex(i);
@@ -518,24 +518,24 @@ nsCSSExpandedDataBlock::Expand(nsCSSComp
   }
 }
 
 void
 nsCSSExpandedDataBlock::ComputeNumProps(uint32_t* aNumPropsNormal,
                                         uint32_t* aNumPropsImportant)
 {
   *aNumPropsNormal = *aNumPropsImportant = 0;
-  for (size_t iHigh = 0; iHigh < nsCSSPropertyIDSet::kChunkCount; ++iHigh) {
+  for (size_t iHigh = 0; iHigh < nsCSSPropertySet::kChunkCount; ++iHigh) {
     if (!mPropertiesSet.HasPropertyInChunk(iHigh))
       continue;
-    for (size_t iLow = 0; iLow < nsCSSPropertyIDSet::kBitsInChunk; ++iLow) {
+    for (size_t iLow = 0; iLow < nsCSSPropertySet::kBitsInChunk; ++iLow) {
       if (!mPropertiesSet.HasPropertyAt(iHigh, iLow))
         continue;
 #ifdef DEBUG
-      nsCSSPropertyID iProp = nsCSSPropertyIDSet::CSSPropertyAt(iHigh, iLow);
+      nsCSSProperty iProp = nsCSSPropertySet::CSSPropertyAt(iHigh, iLow);
 #endif
       MOZ_ASSERT(!nsCSSProps::IsShorthand(iProp), "out of range");
       MOZ_ASSERT(PropertyAt(iProp)->GetUnit() != eCSSUnit_Null,
                  "null value while computing size");
       if (mPropertiesImportant.HasPropertyAt(iHigh, iLow))
         (*aNumPropsImportant)++;
       else
         (*aNumPropsNormal)++;
@@ -565,17 +565,17 @@ nsCSSExpandedDataBlock::Compress(nsCSSCo
   }
 
   /*
    * Save needless copying and allocation by copying the memory
    * corresponding to the stored data in the expanded block, and then
    * clearing the data in the expanded block.
    */
   for (size_t i = 0; i < aOrder.Length(); i++) {
-    nsCSSPropertyID iProp = static_cast<nsCSSPropertyID>(aOrder[i]);
+    nsCSSProperty iProp = static_cast<nsCSSProperty>(aOrder[i]);
     if (iProp >= eCSSProperty_COUNT) {
       // a custom property
       continue;
     }
     MOZ_ASSERT(mPropertiesSet.HasProperty(iProp),
                "aOrder identifies a property not in the expanded "
                "data block");
     MOZ_ASSERT(!nsCSSProps::IsShorthand(iProp), "out of range");
@@ -600,21 +600,21 @@ nsCSSExpandedDataBlock::Compress(nsCSSCo
     MOZ_ASSERT(numPropsImportant == i_important, "bad numProps");
   }
 
 #ifdef DEBUG
   {
     // assert that we didn't have any other properties on this expanded data
     // block that we didn't find in aOrder
     uint32_t numPropsInSet = 0;
-    for (size_t iHigh = 0; iHigh < nsCSSPropertyIDSet::kChunkCount; iHigh++) {
+    for (size_t iHigh = 0; iHigh < nsCSSPropertySet::kChunkCount; iHigh++) {
       if (!mPropertiesSet.HasPropertyInChunk(iHigh)) {
         continue;
       }
-      for (size_t iLow = 0; iLow < nsCSSPropertyIDSet::kBitsInChunk; iLow++) {
+      for (size_t iLow = 0; iLow < nsCSSPropertySet::kBitsInChunk; iLow++) {
         if (mPropertiesSet.HasPropertyAt(iHigh, iLow)) {
           numPropsInSet++;
         }
       }
     }
     MOZ_ASSERT(numPropsNormal + numPropsImportant == numPropsInSet,
                "aOrder missing properties from the expanded data block");
   }
@@ -622,69 +622,69 @@ nsCSSExpandedDataBlock::Compress(nsCSSCo
 
   ClearSets();
   AssertInitialState();
   *aNormalBlock = result_normal.forget();
   *aImportantBlock = result_important.forget();
 }
 
 void
-nsCSSExpandedDataBlock::AddLonghandProperty(nsCSSPropertyID aProperty,
+nsCSSExpandedDataBlock::AddLonghandProperty(nsCSSProperty aProperty,
                                             const nsCSSValue& aValue)
 {
   MOZ_ASSERT(!nsCSSProps::IsShorthand(aProperty),
              "property out of range");
   nsCSSValue& storage = *static_cast<nsCSSValue*>(PropertyAt(aProperty));
   storage = aValue;
   SetPropertyBit(aProperty);
 }
 
 void
 nsCSSExpandedDataBlock::Clear()
 {
-  for (size_t iHigh = 0; iHigh < nsCSSPropertyIDSet::kChunkCount; ++iHigh) {
+  for (size_t iHigh = 0; iHigh < nsCSSPropertySet::kChunkCount; ++iHigh) {
     if (!mPropertiesSet.HasPropertyInChunk(iHigh))
       continue;
-    for (size_t iLow = 0; iLow < nsCSSPropertyIDSet::kBitsInChunk; ++iLow) {
+    for (size_t iLow = 0; iLow < nsCSSPropertySet::kBitsInChunk; ++iLow) {
       if (!mPropertiesSet.HasPropertyAt(iHigh, iLow))
         continue;
-      nsCSSPropertyID iProp = nsCSSPropertyIDSet::CSSPropertyAt(iHigh, iLow);
+      nsCSSProperty iProp = nsCSSPropertySet::CSSPropertyAt(iHigh, iLow);
       ClearLonghandProperty(iProp);
     }
   }
 
   AssertInitialState();
 }
 
 void
-nsCSSExpandedDataBlock::ClearProperty(nsCSSPropertyID aPropID)
+nsCSSExpandedDataBlock::ClearProperty(nsCSSProperty aPropID)
 {
   if (nsCSSProps::IsShorthand(aPropID)) {
     CSSPROPS_FOR_SHORTHAND_SUBPROPERTIES(
         p, aPropID, CSSEnabledState::eIgnoreEnabledState) {
       ClearLonghandProperty(*p);
     }
   } else {
     ClearLonghandProperty(aPropID);
   }
 }
 
 void
-nsCSSExpandedDataBlock::ClearLonghandProperty(nsCSSPropertyID aPropID)
+nsCSSExpandedDataBlock::ClearLonghandProperty(nsCSSProperty aPropID)
 {
   MOZ_ASSERT(!nsCSSProps::IsShorthand(aPropID), "out of range");
 
   ClearPropertyBit(aPropID);
   ClearImportantBit(aPropID);
   PropertyAt(aPropID)->Reset();
 }
 
 bool
 nsCSSExpandedDataBlock::TransferFromBlock(nsCSSExpandedDataBlock& aFromBlock,
-                                          nsCSSPropertyID aPropID,
+                                          nsCSSProperty aPropID,
                                           CSSEnabledState aEnabledState,
                                           bool aIsImportant,
                                           bool aOverrideImportant,
                                           bool aMustCallValueAppended,
                                           css::Declaration* aDeclaration,
                                           nsIDocument* aSheetDocument)
 {
   if (!nsCSSProps::IsShorthand(aPropID)) {
@@ -706,17 +706,17 @@ nsCSSExpandedDataBlock::TransferFromBloc
                                    aMustCallValueAppended, aDeclaration,
                                    aSheetDocument);
   }
   return changed;
 }
 
 bool
 nsCSSExpandedDataBlock::DoTransferFromBlock(nsCSSExpandedDataBlock& aFromBlock,
-                                            nsCSSPropertyID aPropID,
+                                            nsCSSProperty aPropID,
                                             bool aIsImportant,
                                             bool aOverrideImportant,
                                             bool aMustCallValueAppended,
                                             css::Declaration* aDeclaration,
                                             nsIDocument* aSheetDocument)
 {
   bool changed = false;
   MOZ_ASSERT(aFromBlock.HasPropertyBit(aPropID), "oops");
@@ -759,25 +759,25 @@ nsCSSExpandedDataBlock::DoTransferFromBl
    * the destination, copying memory directly, and then using placement
    * new.
    */
   changed |= MoveValue(aFromBlock.PropertyAt(aPropID), PropertyAt(aPropID));
   return changed;
 }
 
 void
-nsCSSExpandedDataBlock::MapRuleInfoInto(nsCSSPropertyID aPropID,
+nsCSSExpandedDataBlock::MapRuleInfoInto(nsCSSProperty aPropID,
                                         nsRuleData* aRuleData) const
 {
   MOZ_ASSERT(!nsCSSProps::IsShorthand(aPropID));
 
   const nsCSSValue* src = PropertyAt(aPropID);
   MOZ_ASSERT(src->GetUnit() != eCSSUnit_Null);
 
-  nsCSSPropertyID physicalProp = aPropID;
+  nsCSSProperty physicalProp = aPropID;
   if (nsCSSProps::PropHasFlags(aPropID, CSS_PROPERTY_LOGICAL)) {
     EnsurePhysicalProperty(physicalProp, aRuleData);
   }
 
   nsCSSValue* dest = aRuleData->ValueFor(physicalProp);
   MOZ_ASSERT(dest->GetUnit() == eCSSUnit_TokenStream &&
              dest->GetTokenStreamValue()->mPropertyID == aPropID);
 
@@ -789,14 +789,14 @@ nsCSSExpandedDataBlock::MapRuleInfoInto(
 #ifdef DEBUG
 void
 nsCSSExpandedDataBlock::DoAssertInitialState()
 {
   mPropertiesSet.AssertIsEmpty("not initial state");
   mPropertiesImportant.AssertIsEmpty("not initial state");
 
   for (uint32_t i = 0; i < eCSSProperty_COUNT_no_shorthands; ++i) {
-    nsCSSPropertyID prop = nsCSSPropertyID(i);
+    nsCSSProperty prop = nsCSSProperty(i);
     MOZ_ASSERT(PropertyAt(prop)->GetUnit() == eCSSUnit_Null,
                "not initial state");
   }
 }
 #endif
--- a/layout/style/nsCSSDataBlock.h
+++ b/layout/style/nsCSSDataBlock.h
@@ -9,17 +9,17 @@
  * declaration, and the code for expanding and compacting it
  */
 
 #ifndef nsCSSDataBlock_h__
 #define nsCSSDataBlock_h__
 
 #include "mozilla/MemoryReporting.h"
 #include "nsCSSProps.h"
-#include "nsCSSPropertyIDSet.h"
+#include "nsCSSPropertySet.h"
 #include "nsCSSValue.h"
 #include "nsStyleStruct.h"
 #include "imgRequestProxy.h"
 
 struct nsRuleData;
 class nsCSSExpandedDataBlock;
 class nsIDocument;
 
@@ -59,27 +59,27 @@ public:
    * Return the location at which the *value* for the property is
    * stored, or null if the block does not contain a value for the
    * property.
    *
    * Inefficient (by design).
    *
    * Must not be called for shorthands.
    */
-  const nsCSSValue* ValueFor(nsCSSPropertyID aProperty) const;
+  const nsCSSValue* ValueFor(nsCSSProperty aProperty) const;
 
   /**
    * Attempt to replace the value for |aProperty| stored in this block
    * with the matching value stored in |aFromBlock|.
    * This method will fail (returning false) if |aProperty| is not
    * already in this block.  It will set |aChanged| to true if it
    * actually made a change to the block, but regardless, if it
    * returns true, the value in |aFromBlock| was erased.
    */
-  bool TryReplaceValue(nsCSSPropertyID aProperty,
+  bool TryReplaceValue(nsCSSProperty aProperty,
                          nsCSSExpandedDataBlock& aFromBlock,
                          bool* aChanged);
 
   /**
    * Clone this block, or return null on out-of-memory.
    */
   nsCSSCompressedDataBlock* Clone() const;
 
@@ -103,34 +103,34 @@ public:
 private:
   void* operator new(size_t aBaseSize, uint32_t aNumProps) {
     MOZ_ASSERT(aBaseSize == sizeof(nsCSSCompressedDataBlock),
                "unexpected size for nsCSSCompressedDataBlock");
     return ::operator new(aBaseSize + DataSize(aNumProps));
   }
 
 public:
-  // Ideally, |nsCSSPropertyID| would be |enum nsCSSPropertyID : int16_t|.  But
+  // Ideally, |nsCSSProperty| would be |enum nsCSSProperty : int16_t|.  But
   // not all of the compilers we use are modern enough to support small
-  // enums.  So we manually squeeze nsCSSPropertyID into 16 bits ourselves.
+  // enums.  So we manually squeeze nsCSSProperty into 16 bits ourselves.
   // The static assertion below ensures it fits.
   typedef int16_t CompressedCSSProperty;
   static const size_t MaxCompressedCSSProperty = INT16_MAX;
 
 private:
   static size_t DataSize(uint32_t aNumProps) {
     return size_t(aNumProps) *
            (sizeof(nsCSSValue) + sizeof(CompressedCSSProperty));
   }
 
   int32_t mStyleBits; // the structs for which we have data, according to
                       // |nsCachedStyleData::GetBitForSID|.
   uint32_t mNumProps;
   // nsCSSValue elements are stored after these fields, and
-  // nsCSSPropertyID elements are stored -- each one compressed as a
+  // nsCSSProperty elements are stored -- each one compressed as a
   // CompressedCSSProperty -- after the nsCSSValue elements.  Space for them
   // is allocated in |operator new| above.  The static assertions following
   // this class make sure that the value and property elements are aligned
   // appropriately.
 
   nsCSSValue* Values() const {
     return (nsCSSValue*)(this + 1);
   }
@@ -139,32 +139,32 @@ private:
     return (CompressedCSSProperty*)(Values() + mNumProps);
   }
 
   nsCSSValue* ValueAtIndex(uint32_t i) const {
     MOZ_ASSERT(i < mNumProps, "value index out of range");
     return Values() + i;
   }
 
-  nsCSSPropertyID PropertyAtIndex(uint32_t i) const {
+  nsCSSProperty PropertyAtIndex(uint32_t i) const {
     MOZ_ASSERT(i < mNumProps, "property index out of range");
-    nsCSSPropertyID prop = (nsCSSPropertyID)CompressedProperties()[i];
+    nsCSSProperty prop = (nsCSSProperty)CompressedProperties()[i];
     MOZ_ASSERT(!nsCSSProps::IsShorthand(prop), "out of range");
     return prop;
   }
 
   void CopyValueToIndex(uint32_t i, nsCSSValue* aValue) {
     new (ValueAtIndex(i)) nsCSSValue(*aValue);
   }
 
   void RawCopyValueToIndex(uint32_t i, nsCSSValue* aValue) {
     memcpy(ValueAtIndex(i), aValue, sizeof(nsCSSValue));
   }
 
-  void SetPropertyAtIndex(uint32_t i, nsCSSPropertyID aProperty) {
+  void SetPropertyAtIndex(uint32_t i, nsCSSProperty aProperty) {
     MOZ_ASSERT(i < mNumProps, "set property index out of range");
     CompressedProperties()[i] = (CompressedCSSProperty)aProperty;
   }
 
   void SetNumPropsToZero() {
     mNumProps = 0;
   }
 };
@@ -176,17 +176,17 @@ static_assert(sizeof(nsCSSCompressedData
 static_assert(NS_ALIGNMENT_OF(nsCSSValue) == 4 || NS_ALIGNMENT_OF(nsCSSValue) == 8,
               "nsCSSValue doesn't align with nsCSSCompressedDataBlock");
 static_assert(NS_ALIGNMENT_OF(nsCSSCompressedDataBlock::CompressedCSSProperty) == 2,
               "CompressedCSSProperty doesn't align with nsCSSValue");
 
 // Make sure that sizeof(CompressedCSSProperty) is big enough.
 static_assert(eCSSProperty_COUNT_no_shorthands <=
               nsCSSCompressedDataBlock::MaxCompressedCSSProperty,
-              "nsCSSPropertyID doesn't fit in StoredSizeOfCSSProperty");
+              "nsCSSProperty doesn't fit in StoredSizeOfCSSProperty");
 
 class nsCSSExpandedDataBlock
 {
   friend class nsCSSCompressedDataBlock;
 
 public:
   nsCSSExpandedDataBlock();
   ~nsCSSExpandedDataBlock();
@@ -213,44 +213,44 @@ public:
   /**
    * Allocate new compressed blocks and transfer all of the state
    * from this expanded block to the new blocks, clearing this
    * expanded block.  A normal block will always be allocated, but
    * an important block will only be allocated if there are
    * !important properties in the expanded block; otherwise
    * |*aImportantBlock| will be set to null.
    *
-   * aOrder is an array of nsCSSPropertyID values specifying the order
+   * aOrder is an array of nsCSSProperty values specifying the order
    * to store values in the two data blocks.
    */
   void Compress(nsCSSCompressedDataBlock **aNormalBlock,
                 nsCSSCompressedDataBlock **aImportantBlock,
                 const nsTArray<uint32_t>& aOrder);
 
   /**
    * Copy a value into this expanded block.  This does NOT destroy
    * the source value object.  |aProperty| cannot be a shorthand.
    */
-  void AddLonghandProperty(nsCSSPropertyID aProperty, const nsCSSValue& aValue);
+  void AddLonghandProperty(nsCSSProperty aProperty, const nsCSSValue& aValue);
 
   /**
    * Clear the state of this expanded block.
    */
   void Clear();
 
   /**
    * Clear the data for the given property (including the set and
    * important bits).  Can be used with shorthand properties.
    */
-  void ClearProperty(nsCSSPropertyID aPropID);
+  void ClearProperty(nsCSSProperty aPropID);
 
   /**
    * Same as ClearProperty, but faster and cannot be used with shorthands.
    */
-  void ClearLonghandProperty(nsCSSPropertyID aPropID);
+  void ClearLonghandProperty(nsCSSProperty aPropID);
 
   /**
    * Transfer the state for |aPropID| (which may be a shorthand)
    * from |aFromBlock| to this block.  The property being transferred
    * is !important if |aIsImportant| is true, and should replace an
    * existing !important property regardless of its own importance
    * if |aOverrideImportant| is true.  |aEnabledState| is used to
    * determine which longhand components of |aPropID| (if it is a
@@ -258,31 +258,31 @@ public:
    *
    * Returns true if something changed, false otherwise.  Calls
    * |ValueAppended| on |aDeclaration| if the property was not
    * previously set, or in any case if |aMustCallValueAppended| is true.
    * Calls |SetDocumentAndPageUseCounter| on |aSheetDocument| if it is
    * non-null and |aPropID| has a use counter.
    */
   bool TransferFromBlock(nsCSSExpandedDataBlock& aFromBlock,
-                         nsCSSPropertyID aPropID,
+                         nsCSSProperty aPropID,
                          mozilla::CSSEnabledState aEnabledState,
                          bool aIsImportant,
                          bool aOverrideImportant,
                          bool aMustCallValueAppended,
                          mozilla::css::Declaration* aDeclaration,
                          nsIDocument* aSheetDocument);
 
   /**
    * Copies the values for aPropID into the specified aRuleData object.
    *
    * This is used for copying parsed-at-computed-value-time properties
    * that had variable references.  aPropID must be a longhand property.
    */
-  void MapRuleInfoInto(nsCSSPropertyID aPropID, nsRuleData* aRuleData) const;
+  void MapRuleInfoInto(nsCSSProperty aPropID, nsRuleData* aRuleData) const;
 
   void AssertInitialState() {
 #ifdef DEBUG
     DoAssertInitialState();
 #endif
   }
 
 private:
@@ -294,77 +294,77 @@ private:
                        uint32_t* aNumPropsImportant);
 
   void DoExpand(nsCSSCompressedDataBlock *aBlock, bool aImportant);
 
   /**
    * Worker for TransferFromBlock; cannot be used with shorthands.
    */
   bool DoTransferFromBlock(nsCSSExpandedDataBlock& aFromBlock,
-                             nsCSSPropertyID aPropID,
+                             nsCSSProperty aPropID,
                              bool aIsImportant,
                              bool aOverrideImportant,
                              bool aMustCallValueAppended,
                              mozilla::css::Declaration* aDeclaration,
                              nsIDocument* aSheetDocument);
 
 #ifdef DEBUG
   void DoAssertInitialState();
 #endif
 
   /*
    * mPropertiesSet stores a bit for every property that is present,
    * to optimize compression of blocks with small numbers of
    * properties (the norm) and to allow quickly checking whether a
    * property is set in this block.
    */
-  nsCSSPropertyIDSet mPropertiesSet;
+  nsCSSPropertySet mPropertiesSet;
   /*
    * mPropertiesImportant indicates which properties are '!important'.
    */
-  nsCSSPropertyIDSet mPropertiesImportant;
+  nsCSSPropertySet mPropertiesImportant;
 
   /*
    * Return the storage location within |this| of the value of the
    * property |aProperty|.
    */
-  nsCSSValue* PropertyAt(nsCSSPropertyID aProperty) {
+  nsCSSValue* PropertyAt(nsCSSProperty aProperty) {
     MOZ_ASSERT(0 <= aProperty &&
                aProperty < eCSSProperty_COUNT_no_shorthands,
                "property out of range");
     return &mValues[aProperty];
   }
-  const nsCSSValue* PropertyAt(nsCSSPropertyID aProperty) const {
+  const nsCSSValue* PropertyAt(nsCSSProperty aProperty) const {
     MOZ_ASSERT(0 <= aProperty &&
                aProperty < eCSSProperty_COUNT_no_shorthands,
                "property out of range");
     return &mValues[aProperty];
   }
 
-  void SetPropertyBit(nsCSSPropertyID aProperty) {
+  void SetPropertyBit(nsCSSProperty aProperty) {
     mPropertiesSet.AddProperty(aProperty);
   }
 
-  void ClearPropertyBit(nsCSSPropertyID aProperty) {
+  void ClearPropertyBit(nsCSSProperty aProperty) {
     mPropertiesSet.RemoveProperty(aProperty);
   }
 
-  bool HasPropertyBit(nsCSSPropertyID aProperty) {
+  bool HasPropertyBit(nsCSSProperty aProperty) {
     return mPropertiesSet.HasProperty(aProperty);
   }
 
-  void SetImportantBit(nsCSSPropertyID aProperty) {
+  void SetImportantBit(nsCSSProperty aProperty) {
     mPropertiesImportant.AddProperty(aProperty);
   }
 
-  void ClearImportantBit(nsCSSPropertyID aProperty) {
+  void ClearImportantBit(nsCSSProperty aProperty) {
     mPropertiesImportant.RemoveProperty(aProperty);
   }
 
-  bool HasImportantBit(nsCSSPropertyID aProperty) {
+  bool HasImportantBit(nsCSSProperty aProperty) {
     return mPropertiesImportant.HasProperty(aProperty);
   }
 
   void ClearSets() {
     mPropertiesSet.Empty();
     mPropertiesImportant.Empty();
   }
 };
--- a/layout/style/nsCSSParser.cpp
+++ b/layout/style/nsCSSParser.cpp
@@ -168,26 +168,26 @@ public:
                              bool*           aChanged);
 
   nsresult ParseRule(const nsAString&        aRule,
                      nsIURI*                 aSheetURL,
                      nsIURI*                 aBaseURL,
                      nsIPrincipal*           aSheetPrincipal,
                      css::Rule**             aResult);
 
-  void ParseProperty(const nsCSSPropertyID aPropID,
+  void ParseProperty(const nsCSSProperty aPropID,
                      const nsAString& aPropValue,
                      nsIURI* aSheetURL,
                      nsIURI* aBaseURL,
                      nsIPrincipal* aSheetPrincipal,
                      css::Declaration* aDeclaration,
                      bool* aChanged,
                      bool aIsImportant,
                      bool aIsSVGMode);
-  void ParseLonghandProperty(const nsCSSPropertyID aPropID,
+  void ParseLonghandProperty(const nsCSSProperty aPropID,
                              const nsAString& aPropValue,
                              nsIURI* aSheetURL,
                              nsIURI* aBaseURL,
                              nsIPrincipal* aSheetPrincipal,
                              nsCSSValue& aValue);
 
   bool ParseTransformProperty(const nsAString& aPropValue,
                               bool aDisallowRelativeValues,
@@ -265,17 +265,17 @@ public:
 
   bool ParseFontFaceDescriptor(nsCSSFontDesc aDescID,
                                const nsAString& aBuffer,
                                nsIURI* aSheetURL,
                                nsIURI* aBaseURL,
                                nsIPrincipal* aSheetPrincipal,
                                nsCSSValue& aValue);
 
-  bool IsValueValidForProperty(const nsCSSPropertyID aPropID,
+  bool IsValueValidForProperty(const nsCSSProperty aPropID,
                                const nsAString& aPropValue);
 
   typedef nsCSSParser::VariableEnumFunc VariableEnumFunc;
 
   /**
    * Parses a CSS token stream value and invokes a callback function for each
    * variable reference that is encountered.
    *
@@ -329,18 +329,18 @@ public:
    *   If a longhand property is to be parsed, aPropertyID is that property,
    *   and aShorthandPropertyID must be eCSSProperty_UNKNOWN.
    * @param aValue The CSS token stream value.
    * @param aVariables The set of variable values to use when resolving variable
    *   references.
    * @param aRuleData The rule data object into which parsed property value for
    *   aPropertyID will be stored.
    */
-  void ParsePropertyWithVariableReferences(nsCSSPropertyID aPropertyID,
-                                           nsCSSPropertyID aShorthandPropertyID,
+  void ParsePropertyWithVariableReferences(nsCSSProperty aPropertyID,
+                                           nsCSSProperty aShorthandPropertyID,
                                            const nsAString& aValue,
                                            const CSSVariableValues* aVariables,
                                            nsRuleData* aRuleData,
                                            nsIURI* aDocURL,
                                            nsIURI* aBaseURL,
                                            nsIPrincipal* aDocPrincipal,
                                            CSSStyleSheet* aSheet,
                                            uint32_t aLineNumber,
@@ -366,17 +366,17 @@ public:
       enabledState |= CSSEnabledState::eInUASheets;
     }
     if (mIsChrome) {
       enabledState |= CSSEnabledState::eInChrome;
     }
     return enabledState;
   }
 
-  nsCSSPropertyID LookupEnabledProperty(const nsAString& aProperty) {
+  nsCSSProperty LookupEnabledProperty(const nsAString& aProperty) {
     return nsCSSProps::LookupProperty(aProperty, EnabledState());
   }
 
 protected:
   class nsAutoParseCompoundProperty;
   friend class nsAutoParseCompoundProperty;
 
   class nsAutoFailingSupportsRule;
@@ -824,45 +824,45 @@ protected:
                                            nsCSSContextType aContext);
   // When we detect a webkit-prefixed gradient expression, this function can be
   // used to parse its body into outparam |aValue|, with the help of the
   // CSSUnprefixingService.
   // Only call if ShouldUseUnprefixingService() returns true.
   bool ParseWebkitPrefixedGradientWithService(nsAString& aPrefixedFuncName,
                                               nsCSSValue& aValue);
 
-  bool ParseProperty(nsCSSPropertyID aPropID);
-  bool ParsePropertyByFunction(nsCSSPropertyID aPropID);
+  bool ParseProperty(nsCSSProperty aPropID);
+  bool ParsePropertyByFunction(nsCSSProperty aPropID);
   CSSParseResult ParseSingleValueProperty(nsCSSValue& aValue,
-                                          nsCSSPropertyID aPropID);
+                                          nsCSSProperty aPropID);
   bool ParseSingleValuePropertyByFunction(nsCSSValue& aValue,
-                                          nsCSSPropertyID aPropID);
+                                          nsCSSProperty aPropID);
 
   // This is similar to ParseSingleValueProperty but only works for
   // properties that are parsed with ParseBoxProperties or
   // ParseGroupedBoxProperty.
   //
   // Only works with variants with the following flags:
   // A, C, H, K, L, N, P, CALC.
   CSSParseResult ParseBoxProperty(nsCSSValue& aValue,
-                                  nsCSSPropertyID aPropID);
+                                  nsCSSProperty aPropID);
 
   enum PriorityParsingStatus {
     ePriority_None,
     ePriority_Important,
     ePriority_Error
   };
   PriorityParsingStatus ParsePriority();
 
 #ifdef MOZ_XUL
   bool ParseTreePseudoElement(nsAtomList **aPseudoElementArgs);
 #endif
 
   // Property specific parsing routines
-  bool ParseImageLayers(const nsCSSPropertyID aTable[]);
+  bool ParseImageLayers(const nsCSSProperty aTable[]);
 
   struct ImageLayersShorthandParseState {
     nsCSSValue&  mColor;
     nsCSSValueList* mImage;
     nsCSSValuePairList* mRepeat;
     nsCSSValueList* mAttachment;   // A property for background layer only
     nsCSSValueList* mClip;
     nsCSSValueList* mOrigin;
@@ -882,52 +882,52 @@ protected:
         mAttachment(aAttachment), mClip(aClip), mOrigin(aOrigin),
         mPositionX(aPositionX), mPositionY(aPositionY),
         mSize(aSize), mComposite(aComposite),
         mMode(aMode) {};
   };
 
   bool IsFunctionTokenValidForImageLayerImage(const nsCSSToken& aToken) const;
   bool ParseImageLayersItem(ImageLayersShorthandParseState& aState,
-                            const nsCSSPropertyID aTable[]);
-
-  bool ParseValueList(nsCSSPropertyID aPropID); // a single value prop-id
-  bool ParseImageLayerRepeat(nsCSSPropertyID aPropID);
+                            const nsCSSProperty aTable[]);
+
+  bool ParseValueList(nsCSSProperty aPropID); // a single value prop-id
+  bool ParseImageLayerRepeat(nsCSSProperty aPropID);
   bool ParseImageLayerRepeatValues(nsCSSValuePair& aValue);
-  bool ParseImageLayerPosition(const nsCSSPropertyID aTable[]);
-  bool ParseImageLayerPositionCoord(nsCSSPropertyID aPropID, bool aIsHorizontal);
+  bool ParseImageLayerPosition(const nsCSSProperty aTable[]);
+  bool ParseImageLayerPositionCoord(nsCSSProperty aPropID, bool aIsHorizontal);
 
   // ParseBoxPositionValues parses the CSS 2.1 background-position syntax,
   // which is still used by some properties. See ParsePositionValue
   // for the css3-background syntax.
   bool ParseBoxPositionValues(nsCSSValuePair& aOut, bool aAcceptsInherit,
                               bool aAllowExplicitCenter = true); // deprecated
 
   // ParsePositionValue parses a CSS <position> value, which is used by
   // the 'background-position' property.
   bool ParsePositionValue(nsCSSValue& aOut);
   bool ParsePositionValueSeparateCoords(nsCSSValue& aOutX, nsCSSValue& aOutY);
 
   bool ParseImageLayerPositionCoordItem(nsCSSValue& aOut, bool aIsHorizontal);
-  bool ParseImageLayerSize(nsCSSPropertyID aPropID);
+  bool ParseImageLayerSize(nsCSSProperty aPropID);
   bool ParseImageLayerSizeValues(nsCSSValuePair& aOut);
   bool ParseBorderColor();
-  bool ParseBorderColors(nsCSSPropertyID aProperty);
+  bool ParseBorderColors(nsCSSProperty aProperty);
   void SetBorderImageInitialValues();
   bool ParseBorderImageRepeat(bool aAcceptsInherit);
   // If ParseBorderImageSlice returns false, aConsumedTokens indicates
   // whether or not any tokens were consumed (in other words, was the property
   // in error or just not present).  If ParseBorderImageSlice returns true
   // aConsumedTokens is always true.
   bool ParseBorderImageSlice(bool aAcceptsInherit, bool* aConsumedTokens);
   bool ParseBorderImageWidth(bool aAcceptsInherit);
   bool ParseBorderImageOutset(bool aAcceptsInherit);
   bool ParseBorderImage();
   bool ParseBorderSpacing();
-  bool ParseBorderSide(const nsCSSPropertyID aPropIDs[],
+  bool ParseBorderSide(const nsCSSProperty aPropIDs[],
                          bool aSetAllSides);
   bool ParseBorderStyle();
   bool ParseBorderWidth();
 
   bool ParseCalc(nsCSSValue &aValue, uint32_t aVariantMask);
   bool ParseCalcAdditiveExpression(nsCSSValue& aValue,
                                    uint32_t& aVariantMask);
   bool ParseCalcMultiplicativeExpression(nsCSSValue& aValue,
@@ -958,17 +958,17 @@ protected:
   bool ParseGridLineNameListRepeat(nsCSSValueList** aTailPtr);
   bool ParseOptionalLineNameListAfterSubgrid(nsCSSValue& aValue);
 
   CSSParseResult ParseGridTrackBreadth(nsCSSValue& aValue);
   // eFixedTrackSize in aFlags makes it parse a <fixed-size>.
   CSSParseResult ParseGridTrackSize(nsCSSValue& aValue,
     GridTrackSizeFlags aFlags = GridTrackSizeFlags::eDefaultTrackSize);
 
-  bool ParseGridAutoColumnsRows(nsCSSPropertyID aPropID);
+  bool ParseGridAutoColumnsRows(nsCSSProperty aPropID);
   bool ParseGridTrackListRepeat(nsCSSValueList** aTailPtr);
   bool ParseGridTrackRepeatIntro(bool            aForSubgrid,
                                  int32_t*        aRepetitions,
                                  Maybe<int32_t>* aRepeatAutoEnum);
 
   // Assuming a [ <line-names>? ] has already been parsed,
   // parse the rest of a <track-list>.
   //
@@ -978,53 +978,53 @@ protected:
   // grid-template-rows and grid-template-areas.
   //
   // On success, |aValue| will be a list of odd length >= 3,
   // starting with a <line-names> (which is itself a list)
   // and alternating between that and <track-size>.
   bool ParseGridTrackListWithFirstLineNames(nsCSSValue& aValue,
                                             const nsCSSValue& aFirstLineNames);
 
-  bool ParseGridTrackList(nsCSSPropertyID aPropID);
-  bool ParseGridTemplateColumnsRows(nsCSSPropertyID aPropID);
+  bool ParseGridTrackList(nsCSSProperty aPropID);
+  bool ParseGridTemplateColumnsRows(nsCSSProperty aPropID);
 
   // |aAreaIndices| is a lookup table to help us parse faster,
   // mapping area names to indices in |aResult.mNamedAreas|.
   bool ParseGridTemplateAreasLine(const nsAutoString& aInput,
                                   css::GridTemplateAreasValue* aResult,
                                   nsDataHashtable<nsStringHashKey, uint32_t>& aAreaIndices);
   bool ParseGridTemplateAreas();
   bool ParseGridTemplate();
   bool ParseGridTemplateAfterString(const nsCSSValue& aFirstLineNames);
   bool ParseGrid();
   bool ParseGridShorthandAutoProps();
   bool ParseGridLine(nsCSSValue& aValue);
-  bool ParseGridColumnRowStartEnd(nsCSSPropertyID aPropID);
-  bool ParseGridColumnRow(nsCSSPropertyID aStartPropID,
-                          nsCSSPropertyID aEndPropID);
+  bool ParseGridColumnRowStartEnd(nsCSSProperty aPropID);
+  bool ParseGridColumnRow(nsCSSProperty aStartPropID,
+                          nsCSSProperty aEndPropID);
   bool ParseGridArea();
   bool ParseGridGap();
 
   bool ParseInitialLetter();
 
   // parsing 'align/justify-items/self' from the css-align spec
   bool ParseAlignJustifyPosition(nsCSSValue& aResult,
                                  const KTableEntry aTable[]);
   bool ParseJustifyItems();
   bool ParseAlignItems();
-  bool ParseAlignJustifySelf(nsCSSPropertyID aPropID);
+  bool ParseAlignJustifySelf(nsCSSProperty aPropID);
   // parsing 'align/justify-content' from the css-align spec
-  bool ParseAlignJustifyContent(nsCSSPropertyID aPropID);
+  bool ParseAlignJustifyContent(nsCSSProperty aPropID);
 
   // for 'clip' and '-moz-image-region'
-  bool ParseRect(nsCSSPropertyID aPropID);
+  bool ParseRect(nsCSSProperty aPropID);
   bool ParseColumns();
   bool ParseContain(nsCSSValue& aValue);
   bool ParseContent();
-  bool ParseCounterData(nsCSSPropertyID aPropID);
+  bool ParseCounterData(nsCSSProperty aPropID);
   bool ParseCursor();
   bool ParseFont();
   bool ParseFontSynthesis(nsCSSValue& aValue);
   bool ParseSingleAlternate(int32_t& aWhichFeature, nsCSSValue& aValue);
   bool ParseFontVariantAlternates(nsCSSValue& aValue);
   bool MergeBitmaskValue(int32_t aNewValue, const int32_t aMasks[],
                          int32_t& aMergedValue);
   bool ParseBitmaskValues(nsCSSValue& aValue,
@@ -1060,45 +1060,45 @@ protected:
   bool ParseTextEmphasis();
   bool ParseTextEmphasisPosition(nsCSSValue& aValue);
   bool ParseTextEmphasisStyle(nsCSSValue& aValue);
   bool ParseTextCombineUpright(nsCSSValue& aValue);
   bool ParseTextOverflow(nsCSSValue& aValue);
   bool ParseTouchAction(nsCSSValue& aValue);
 
   bool ParseShadowItem(nsCSSValue& aValue, bool aIsBoxShadow);
-  bool ParseShadowList(nsCSSPropertyID aProperty);
+  bool ParseShadowList(nsCSSProperty aProperty);
   bool ParseShapeOutside(nsCSSValue& aValue);
   bool ParseTransitionProperty();
   bool ParseTransitionTimingFunctionValues(nsCSSValue& aValue);
   bool ParseTransitionTimingFunctionValueComponent(float& aComponent,
                                                      char aStop,
                                                      bool aIsXPoint);
   bool ParseTransitionStepTimingFunctionValues(nsCSSValue& aValue);
   enum ParseAnimationOrTransitionShorthandResult {
     eParseAnimationOrTransitionShorthand_Values,
     eParseAnimationOrTransitionShorthand_Inherit,
     eParseAnimationOrTransitionShorthand_Error
   };
   ParseAnimationOrTransitionShorthandResult
-    ParseAnimationOrTransitionShorthand(const nsCSSPropertyID* aProperties,
+    ParseAnimationOrTransitionShorthand(const nsCSSProperty* aProperties,
                                         const nsCSSValue* aInitialValues,
                                         nsCSSValue* aValues,
                                         size_t aNumProperties);
   bool ParseTransition();
   bool ParseAnimation();
   bool ParseWillChange();
 
-  bool ParsePaint(nsCSSPropertyID aPropID);
+  bool ParsePaint(nsCSSProperty aPropID);
   bool ParseDasharray();
   bool ParseMarker();
   bool ParsePaintOrder();
   bool ParseAll();
   bool ParseScrollSnapType();
-  bool ParseScrollSnapPoints(nsCSSValue& aValue, nsCSSPropertyID aPropID);
+  bool ParseScrollSnapPoints(nsCSSValue& aValue, nsCSSProperty aPropID);
   bool ParseScrollSnapDestination(nsCSSValue& aValue);
   bool ParseScrollSnapCoordinate(nsCSSValue& aValue);
   bool ParseWebkitTextStroke();
 
   /**
    * Parses a variable value from a custom property declaration.
    *
    * @param aType Out parameter into which will be stored the type of variable
@@ -1141,26 +1141,26 @@ protected:
   bool BackslashDropped();
 
   /**
    * Calls AppendImpliedEOFCharacters on mScanner.
    */
   void AppendImpliedEOFCharacters(nsAString& aResult);
 
   // Reused utility parsing routines
-  void AppendValue(nsCSSPropertyID aPropID, const nsCSSValue& aValue);
-  bool ParseBoxProperties(const nsCSSPropertyID aPropIDs[]);
+  void AppendValue(nsCSSProperty aPropID, const nsCSSValue& aValue);
+  bool ParseBoxProperties(const nsCSSProperty aPropIDs[]);
   bool ParseGroupedBoxProperty(int32_t aVariantMask,
                                nsCSSValue& aValue);
-  bool ParseBoxCornerRadius(const nsCSSPropertyID aPropID);
+  bool ParseBoxCornerRadius(const nsCSSProperty aPropID);
   bool ParseBoxCornerRadiiInternals(nsCSSValue array[]);
-  bool ParseBoxCornerRadii(const nsCSSPropertyID aPropIDs[]);
+  bool ParseBoxCornerRadii(const nsCSSProperty aPropIDs[]);
 
   int32_t ParseChoice(nsCSSValue aValues[],
-                      const nsCSSPropertyID aPropIDs[], int32_t aNumIDs);
+                      const nsCSSProperty aPropIDs[], int32_t aNumIDs);
   CSSParseResult ParseColor(nsCSSValue& aValue);
   bool ParseNumberColorComponent(uint8_t& aComponent, char aStop);
   bool ParsePercentageColorComponent(float& aComponent, char aStop);
   // ParseHSLColor parses everything starting with the opening '('
   // up through and including the aStop char.
   bool ParseHSLColor(float& aHue, float& aSaturation, float& aLightness,
                      char aStop);
   // ParseColorOpacity will enforce that the color ends with a ')'
@@ -1866,17 +1866,17 @@ CSSParserImpl::ParseRule(const nsAString
     }
   }
 
   ReleaseScanner();
   return rv;
 }
 
 void
-CSSParserImpl::ParseLonghandProperty(const nsCSSPropertyID aPropID,
+CSSParserImpl::ParseLonghandProperty(const nsCSSProperty aPropID,
                                      const nsAString& aPropValue,
                                      nsIURI* aSheetURL,
                                      nsIURI* aBaseURL,
                                      nsIPrincipal* aSheetPrincipal,
                                      nsCSSValue& aValue)
 {
   MOZ_ASSERT(aPropID < eCSSProperty_COUNT_no_shorthands,
              "ParseLonghandProperty must only take a longhand property");
@@ -1935,17 +1935,17 @@ CSSParserImpl::ParseTransformProperty(co
   }
 
   ReleaseScanner();
 
   return parsedOK;
 }
 
 void
-CSSParserImpl::ParseProperty(const nsCSSPropertyID aPropID,
+CSSParserImpl::ParseProperty(const nsCSSProperty aPropID,
                              const nsAString& aPropValue,
                              nsIURI* aSheetURI,
                              nsIURI* aBaseURI,
                              nsIPrincipal* aSheetPrincipal,
                              css::Declaration* aDeclaration,
                              bool* aChanged,
                              bool aIsImportant,
                              bool aIsSVGMode)
@@ -2335,17 +2335,17 @@ CSSParserImpl::ParseKeyframeSelectorStri
 
 bool
 CSSParserImpl::EvaluateSupportsDeclaration(const nsAString& aProperty,
                                            const nsAString& aValue,
                                            nsIURI* aDocURL,
                                            nsIURI* aBaseURL,
                                            nsIPrincipal* aDocPrincipal)
 {
-  nsCSSPropertyID propID = LookupEnabledProperty(aProperty);
+  nsCSSProperty propID = LookupEnabledProperty(aProperty);
   if (propID == eCSSProperty_UNKNOWN) {
     return false;
   }
 
   nsCSSScanner scanner(aValue, 0);
   css::ErrorReporter reporter(scanner, mSheet, mChildLoader, aDocURL);
   InitScanner(scanner, reporter, aDocURL, aBaseURL, aDocPrincipal);
   nsAutoSuppressErrors suppressErrors(this);
@@ -2914,18 +2914,18 @@ CSSParserImpl::ResolveVariableValue(cons
                                                   aFirstToken, aLastToken);
 
   ReleaseScanner();
   return valid;
 }
 
 void
 CSSParserImpl::ParsePropertyWithVariableReferences(
-                                            nsCSSPropertyID aPropertyID,
-                                            nsCSSPropertyID aShorthandPropertyID,
+                                            nsCSSProperty aPropertyID,
+                                            nsCSSProperty aShorthandPropertyID,
                                             const nsAString& aValue,
                                             const CSSVariableValues* aVariables,
                                             nsRuleData* aRuleData,
                                             nsIURI* aDocURL,
                                             nsIURI* aBaseURL,
                                             nsIPrincipal* aDocPrincipal,
                                             CSSStyleSheet* aSheet,
                                             uint32_t aLineNumber,
@@ -2954,17 +2954,17 @@ CSSParserImpl::ParsePropertyWithVariable
       } else {
         REPORT_UNEXPECTED(PEValueWithVariablesFallbackInitial);
       }
       OUTPUT_ERROR_WITH_POSITION(aLineNumber, aLineOffset);
     }
     ReleaseScanner();
   }
 
-  nsCSSPropertyID propertyToParse =
+  nsCSSProperty propertyToParse =
     aShorthandPropertyID != eCSSProperty_UNKNOWN ? aShorthandPropertyID :
                                                    aPropertyID;
 
   // Parse the property with that resolved value.
   if (valid) {
     nsCSSScanner scanner(expandedValue, 0);
     css::ErrorReporter reporter(scanner, aSheet, mChildLoader, aDocURL);
     InitScanner(scanner, reporter, aDocURL, aBaseURL, aDocPrincipal);
@@ -4657,17 +4657,17 @@ CSSParserImpl::ParseSupportsConditionInP
 
   if (mToken.mType == eCSSToken_Ident) {
     if (!mToken.mIdent.LowerCaseEqualsLiteral("not")) {
       nsAutoString propertyName = mToken.mIdent;
       if (!ExpectSymbol(':', true)) {
         return false;
       }
 
-      nsCSSPropertyID propID = LookupEnabledProperty(propertyName);
+      nsCSSProperty propID = LookupEnabledProperty(propertyName);
       if (propID == eCSSProperty_UNKNOWN) {
         if (ExpectSymbol(')', true)) {
           UngetToken();
           return false;
         }
         aConditionMet = false;
         SkipUntil(')');
         UngetToken();
@@ -7280,17 +7280,17 @@ CSSParserImpl::ParseDeclaration(css::Dec
     return false;
   }
 
   // Don't report property parse errors if we're inside a failing @supports
   // rule.
   nsAutoSuppressErrors suppressErrors(this, mInFailingSupportsRule);
 
   // Information about a parsed non-custom property.
-  nsCSSPropertyID propID;
+  nsCSSProperty propID;
 
   // Information about a parsed custom property.
   CSSVariableDeclarations::Type variableType;
   nsString variableValue;
 
   // Check if the property name is a custom property.
   bool customProperty = nsLayoutUtils::CSSVariablesEnabled() &&
                         nsCSSProps::IsCustomPropertyName(propertyName) &&
@@ -7397,57 +7397,57 @@ CSSParserImpl::ParseDeclaration(css::Dec
                                          status == ePriority_Important,
                                          false, aMustCallValueAppended,
                                          aDeclaration, GetDocument());
   }
 
   return true;
 }
 
-static const nsCSSPropertyID kBorderTopIDs[] = {
+static const nsCSSProperty kBorderTopIDs[] = {
   eCSSProperty_border_top_width,
   eCSSProperty_border_top_style,
   eCSSProperty_border_top_color
 };
-static const nsCSSPropertyID kBorderRightIDs[] = {
+static const nsCSSProperty kBorderRightIDs[] = {
   eCSSProperty_border_right_width,
   eCSSProperty_border_right_style,
   eCSSProperty_border_right_color
 };
-static const nsCSSPropertyID kBorderBottomIDs[] = {
+static const nsCSSProperty kBorderBottomIDs[] = {
   eCSSProperty_border_bottom_width,
   eCSSProperty_border_bottom_style,
   eCSSProperty_border_bottom_color
 };
-static const nsCSSPropertyID kBorderLeftIDs[] = {
+static const nsCSSProperty kBorderLeftIDs[] = {
   eCSSProperty_border_left_width,
   eCSSProperty_border_left_style,
   eCSSProperty_border_left_color
 };
-static const nsCSSPropertyID kBorderInlineStartIDs[] = {
+static const nsCSSProperty kBorderInlineStartIDs[] = {
   eCSSProperty_border_inline_start_width,
   eCSSProperty_border_inline_start_style,
   eCSSProperty_border_inline_start_color
 };
-static const nsCSSPropertyID kBorderInlineEndIDs[] = {
+static const nsCSSProperty kBorderInlineEndIDs[] = {
   eCSSProperty_border_inline_end_width,
   eCSSProperty_border_inline_end_style,
   eCSSProperty_border_inline_end_color
 };
-static const nsCSSPropertyID kBorderBlockStartIDs[] = {
+static const nsCSSProperty kBorderBlockStartIDs[] = {
   eCSSProperty_border_block_start_width,
   eCSSProperty_border_block_start_style,
   eCSSProperty_border_block_start_color
 };
-static const nsCSSPropertyID kBorderBlockEndIDs[] = {
+static const nsCSSProperty kBorderBlockEndIDs[] = {
   eCSSProperty_border_block_end_width,
   eCSSProperty_border_block_end_style,
   eCSSProperty_border_block_end_color
 };
-static const nsCSSPropertyID kColumnRuleIDs[] = {
+static const nsCSSProperty kColumnRuleIDs[] = {
   eCSSProperty__moz_column_rule_width,
   eCSSProperty__moz_column_rule_style,
   eCSSProperty__moz_column_rule_color
 };
 
 bool
 CSSParserImpl::ParseEnum(nsCSSValue& aValue,
                          const KTableEntry aKeywordTable[])
@@ -8482,17 +8482,17 @@ CSSParserImpl::ParseFlex()
 
   return true;
 }
 
 // flex-flow: <flex-direction> || <flex-wrap>
 bool
 CSSParserImpl::ParseFlexFlow()
 {
-  static const nsCSSPropertyID kFlexFlowSubprops[] = {
+  static const nsCSSProperty kFlexFlowSubprops[] = {
     eCSSProperty_flex_direction,
     eCSSProperty_flex_wrap
   };
   const size_t numProps = MOZ_ARRAY_LENGTH(kFlexFlowSubprops);
   nsCSSValue values[numProps];
 
   int32_t found = ParseChoice(values, kFlexFlowSubprops, numProps);
 
@@ -8774,17 +8774,17 @@ CSSParserImpl::ParseGridTrackSize(nsCSSV
     }
     return CSSParseResult::Ok;
   }
   SkipUntil(')');
   return CSSParseResult::Error;
 }
 
 bool
-CSSParserImpl::ParseGridAutoColumnsRows(nsCSSPropertyID aPropID)
+CSSParserImpl::ParseGridAutoColumnsRows(nsCSSProperty aPropID)
 {
   nsCSSValue value;
   if (ParseSingleTokenVariant(value, VARIANT_INHERIT, nullptr) ||
       ParseGridTrackSize(value) == CSSParseResult::Ok) {
     AppendValue(aPropID, value);
     return true;
   }
   return false;
@@ -9150,30 +9150,30 @@ CSSParserImpl::ParseGridTrackListRepeat(
   tail = tail->mNext;
   tail->mValue = lastLineNames;
 
   *aTailPtr = tail;
   return true;
 }
 
 bool
-CSSParserImpl::ParseGridTrackList(nsCSSPropertyID aPropID)
+CSSParserImpl::ParseGridTrackList(nsCSSProperty aPropID)
 {
   nsCSSValue value;
   nsCSSValue firstLineNames;
   if (ParseGridLineNames(firstLineNames) == CSSParseResult::Error ||
       !ParseGridTrackListWithFirstLineNames(value, firstLineNames)) {
     return false;
   }
   AppendValue(aPropID, value);
   return true;
 }
 
 bool
-CSSParserImpl::ParseGridTemplateColumnsRows(nsCSSPropertyID aPropID)
+CSSParserImpl::ParseGridTemplateColumnsRows(nsCSSProperty aPropID)
 {
   nsCSSValue value;
   if (ParseSingleTokenVariant(value, VARIANT_INHERIT | VARIANT_NONE, nullptr)) {
     AppendValue(aPropID, value);
     return true;
   }
 
   nsSubstring* ident = NextIdent();
@@ -9482,17 +9482,17 @@ CSSParserImpl::ParseGridTemplateAfterStr
 
 // <'grid-template'> |
 // [ <'grid-auto-flow'> [ <'grid-auto-rows'> [ / <'grid-auto-columns'> ]? ]? ]
 bool
 CSSParserImpl::ParseGrid()
 {
   nsCSSValue value;
   if (ParseSingleTokenVariant(value, VARIANT_INHERIT, nullptr)) {
-    for (const nsCSSPropertyID* subprops =
+    for (const nsCSSProperty* subprops =
            nsCSSProps::SubpropertyEntryFor(eCSSProperty_grid);
          *subprops != eCSSProperty_UNKNOWN; ++subprops) {
       AppendValue(*subprops, value);
     }
     return true;
   }
 
   // An empty value is always invalid.
@@ -9656,17 +9656,17 @@ CSSParserImpl::ParseGridLine(nsCSSValue&
   }
   if (hasIdent) {
     item->mValue = ident;
   }
   return true;
 }
 
 bool
-CSSParserImpl::ParseGridColumnRowStartEnd(nsCSSPropertyID aPropID)
+CSSParserImpl::ParseGridColumnRowStartEnd(nsCSSProperty aPropID)
 {
   nsCSSValue value;
   if (ParseSingleTokenVariant(value, VARIANT_INHERIT, nullptr) ||
       ParseGridLine(value)) {
     AppendValue(aPropID, value);
     return true;
   }
   return false;
@@ -9683,18 +9683,18 @@ HandleGridLineFallback(const nsCSSValue&
       !aFallback.GetListValue()->mNext) {
     aValue = aFallback;
   } else {
     aValue.SetAutoValue();
   }
 }
 
 bool
-CSSParserImpl::ParseGridColumnRow(nsCSSPropertyID aStartPropID,
-                                  nsCSSPropertyID aEndPropID)
+CSSParserImpl::ParseGridColumnRow(nsCSSProperty aStartPropID,
+                                  nsCSSProperty aEndPropID)
 {
   nsCSSValue value;
   nsCSSValue secondValue;
   if (ParseSingleTokenVariant(value, VARIANT_INHERIT, nullptr)) {
     AppendValue(aStartPropID, value);
     AppendValue(aEndPropID, value);
     return true;
   }
@@ -9900,17 +9900,17 @@ CSSParserImpl::ParseAlignItems()
   }
   AppendValue(eCSSProperty_align_items, value);
   return true;
 }
 
 // auto | normal | stretch | <baseline-position> |
 // [ <overflow-position>? && <self-position> ]
 bool
-CSSParserImpl::ParseAlignJustifySelf(nsCSSPropertyID aPropID)
+CSSParserImpl::ParseAlignJustifySelf(nsCSSProperty aPropID)
 {
   nsCSSValue value;
   if (!ParseSingleTokenVariant(value, VARIANT_INHERIT, nullptr)) {
     if (!ParseEnum(value, nsCSSProps::kAlignAutoNormalStretchBaseline)) {
       if (!ParseAlignJustifyPosition(value, nsCSSProps::kAlignSelfPosition) ||
           value.GetUnit() == eCSSUnit_Null) {
         return false;
       }
@@ -9919,17 +9919,17 @@ CSSParserImpl::ParseAlignJustifySelf(nsC
   AppendValue(aPropID, value);
   return true;
 }
 
 // normal | <baseline-position> | [ <content-distribution> ||
 //   [ <overflow-position>? && <content-position> ] ]
 // (the part after the || is called <*-position> below)
 bool
-CSSParserImpl::ParseAlignJustifyContent(nsCSSPropertyID aPropID)
+CSSParserImpl::ParseAlignJustifyContent(nsCSSProperty aPropID)
 {
   nsCSSValue value;
   if (!ParseSingleTokenVariant(value, VARIANT_INHERIT, nullptr)) {
     if (!ParseEnum(value, nsCSSProps::kAlignNormalBaseline)) {
       nsCSSValue fallbackValue;
       if (!ParseEnum(value, nsCSSProps::kAlignContentDistribution)) {
         if (!ParseAlignJustifyPosition(fallbackValue,
                                        nsCSSProps::kAlignContentPosition) ||
@@ -10862,17 +10862,17 @@ CSSParserImpl::ParseWebkitGradient(nsCSS
 
   aValue.SetGradientValue(cssGradient);
   return true;
 }
 
 bool
 CSSParserImpl::ParseWebkitTextStroke()
 {
-  static const nsCSSPropertyID kWebkitTextStrokeIDs[] = {
+  static const nsCSSProperty kWebkitTextStrokeIDs[] = {
     eCSSProperty__webkit_text_stroke_width,
     eCSSProperty__webkit_text_stroke_color
   };
 
   const size_t numProps = MOZ_ARRAY_LENGTH(kWebkitTextStrokeIDs);
   nsCSSValue values[numProps];
 
   int32_t found = ParseChoice(values, kWebkitTextStrokeIDs, numProps);
@@ -10892,17 +10892,17 @@ CSSParserImpl::ParseWebkitTextStroke()
     AppendValue(kWebkitTextStrokeIDs[index], values[index]);
   }
 
   return true;
 }
 
   int32_t
 CSSParserImpl::ParseChoice(nsCSSValue aValues[],
-                           const nsCSSPropertyID aPropIDs[], int32_t aNumIDs)
+                           const nsCSSProperty aPropIDs[], int32_t aNumIDs)
 {
   int32_t found = 0;
   nsAutoParseCompoundProperty compound(this);
 
   int32_t loop;
   for (loop = 0; loop < aNumIDs; loop++) {
     // Try each property parser in order
     int32_t hadFound = found;
@@ -10965,28 +10965,28 @@ CSSParserImpl::ParseChoice(nsCSSValue aV
         }
       }
     }
   }
   return found;
 }
 
 void
-CSSParserImpl::AppendValue(nsCSSPropertyID aPropID, const nsCSSValue& aValue)
+CSSParserImpl::AppendValue(nsCSSProperty aPropID, const nsCSSValue& aValue)
 {
   mTempData.AddLonghandProperty(aPropID, aValue);
 }
 
 /**
  * Parse a "box" property. Box properties have 1 to 4 values. When less
  * than 4 values are provided a standard mapping is used to replicate
  * existing values.
  */
 bool
-CSSParserImpl::ParseBoxProperties(const nsCSSPropertyID aPropIDs[])
+CSSParserImpl::ParseBoxProperties(const nsCSSProperty aPropIDs[])
 {
   // Get up to four values for the property
   int32_t count = 0;
   nsCSSRect result;
   NS_FOR_CSS_SIDES (index) {
     CSSParseResult parseResult =
       ParseBoxProperty(result.*(nsCSSRect::sides[index]), aPropIDs[index]);
     if (parseResult == CSSParseResult::NotFound) {
@@ -11068,17 +11068,17 @@ CSSParserImpl::ParseGroupedBoxProperty(i
     case 3: // Make left == right
       result.mLeft = result.mRight;
   }
 
   return true;
 }
 
 bool
-CSSParserImpl::ParseBoxCornerRadius(nsCSSPropertyID aPropID)
+CSSParserImpl::ParseBoxCornerRadius(nsCSSProperty aPropID)
 {
   nsCSSValue dimenX, dimenY;
   // required first value
   if (ParseNonNegativeVariant(dimenX, VARIANT_HLP | VARIANT_CALC, nullptr) !=
       CSSParseResult::Ok) {
     return false;
   }
 
@@ -11192,55 +11192,55 @@ CSSParserImpl::ParseBoxCornerRadiiIntern
       pair.SetPairValue(x, y);
       array[side] = pair;
     }
   }
   return true;
 }
 
 bool
-CSSParserImpl::ParseBoxCornerRadii(const nsCSSPropertyID aPropIDs[])
+CSSParserImpl::ParseBoxCornerRadii(const nsCSSProperty aPropIDs[])
 {
   nsCSSValue value[4];
   if (!ParseBoxCornerRadiiInternals(value)) {
     return false;
   }
 
   NS_FOR_CSS_SIDES(side) {
     AppendValue(aPropIDs[side], value[side]);
   }
   return true;
 }
 
 // These must be in CSS order (top,right,bottom,left) for indexing to work
-static const nsCSSPropertyID kBorderStyleIDs[] = {
+static const nsCSSProperty kBorderStyleIDs[] = {
   eCSSProperty_border_top_style,
   eCSSProperty_border_right_style,
   eCSSProperty_border_bottom_style,
   eCSSProperty_border_left_style
 };
-static const nsCSSPropertyID kBorderWidthIDs[] = {
+static const nsCSSProperty kBorderWidthIDs[] = {
   eCSSProperty_border_top_width,
   eCSSProperty_border_right_width,
   eCSSProperty_border_bottom_width,
   eCSSProperty_border_left_width
 };
-static const nsCSSPropertyID kBorderColorIDs[] = {
+static const nsCSSProperty kBorderColorIDs[] = {
   eCSSProperty_border_top_color,
   eCSSProperty_border_right_color,
   eCSSProperty_border_bottom_color,
   eCSSProperty_border_left_color
 };
-static const nsCSSPropertyID kBorderRadiusIDs[] = {
+static const nsCSSProperty kBorderRadiusIDs[] = {
   eCSSProperty_border_top_left_radius,
   eCSSProperty_border_top_right_radius,
   eCSSProperty_border_bottom_right_radius,
   eCSSProperty_border_bottom_left_radius
 };
-static const nsCSSPropertyID kOutlineRadiusIDs[] = {
+static const nsCSSProperty kOutlineRadiusIDs[] = {
   eCSSProperty__moz_outline_radius_topLeft,
   eCSSProperty__moz_outline_radius_topRight,
   eCSSProperty__moz_outline_radius_bottomRight,
   eCSSProperty__moz_outline_radius_bottomLeft
 };
 
 void
 CSSParserImpl::SaveInputState(CSSParserInputState& aState)
@@ -11254,17 +11254,17 @@ void
 CSSParserImpl::RestoreSavedInputState(const CSSParserInputState& aState)
 {
   mToken = aState.mToken;
   mHavePushBack = aState.mHavePushBack;
   mScanner->RestoreSavedPosition(aState.mPosition);
 }
 
 bool
-CSSParserImpl::ParseProperty(nsCSSPropertyID aPropID)
+CSSParserImpl::ParseProperty(nsCSSProperty aPropID)
 {
   // Can't use AutoRestore<bool> because it's a bitfield.
   MOZ_ASSERT(!mHashlessColorQuirk,
              "hashless color quirk should not be set");
   MOZ_ASSERT(!mUnitlessLengthQuirk,
              "unitless length quirk should not be set");
   MOZ_ASSERT(aPropID != eCSSPropertyExtra_variable);
 
@@ -11468,17 +11468,17 @@ CSSParserImpl::ParseProperty(nsCSSProper
     mHashlessColorQuirk = false;
     mUnitlessLengthQuirk = false;
   }
 
   return result;
 }
 
 bool
-CSSParserImpl::ParsePropertyByFunction(nsCSSPropertyID aPropID)
+CSSParserImpl::ParsePropertyByFunction(nsCSSProperty aPropID)
 {
   switch (aPropID) {  // handle shorthand or multiple properties
   case eCSSProperty_background:
     return ParseImageLayers(nsStyleImageLayers::kBackgroundLayerTable);
   case eCSSProperty_background_repeat:
     return ParseImageLayerRepeat(eCSSProperty_background_repeat);
   case eCSSProperty_background_position:
     return ParseImageLayerPosition(nsStyleImageLayers::kBackgroundLayerTable);
@@ -11693,17 +11693,17 @@ CSSParserImpl::ParsePropertyByFunction(n
 #define BG_RIGHT   NS_STYLE_IMAGELAYER_POSITION_RIGHT
 #define BG_CTB    (BG_CENTER | BG_TOP | BG_BOTTOM)
 #define BG_TB     (BG_TOP | BG_BOTTOM)
 #define BG_CLR    (BG_CENTER | BG_LEFT | BG_RIGHT)
 #define BG_LR     (BG_LEFT | BG_RIGHT)
 
 CSSParseResult
 CSSParserImpl::ParseBoxProperty(nsCSSValue& aValue,
-                                nsCSSPropertyID aPropID)
+                                nsCSSProperty aPropID)
 {
   if (aPropID < 0 || aPropID >= eCSSProperty_COUNT_no_shorthands) {
     MOZ_ASSERT(false, "must only be called for longhand properties");
     return CSSParseResult::NotFound;
   }
 
   MOZ_ASSERT(!nsCSSProps::PropHasFlags(aPropID,
                                        CSS_PROPERTY_VALUE_PARSER_FUNCTION),
@@ -11724,17 +11724,17 @@ CSSParserImpl::ParseBoxProperty(nsCSSVal
   const KTableEntry* kwtable = nsCSSProps::kKeywordTableTable[aPropID];
   uint32_t restrictions = nsCSSProps::ValueRestrictions(aPropID);
 
   return ParseVariantWithRestrictions(aValue, variant, kwtable, restrictions);
 }
 
 bool
 CSSParserImpl::ParseSingleValuePropertyByFunction(nsCSSValue& aValue,
-                                                  nsCSSPropertyID aPropID)
+                                                  nsCSSProperty aPropID)
 {
   switch (aPropID) {
     case eCSSProperty_font_family:
       return ParseFamily(aValue);
     case eCSSProperty_font_synthesis:
       return ParseFontSynthesis(aValue);
     case eCSSProperty_font_variant_alternates:
       return ParseFontVariantAlternates(aValue);
@@ -11783,17 +11783,17 @@ CSSParserImpl::ParseSingleValuePropertyB
     default:
       MOZ_ASSERT(false, "should not reach here");
       return false;
   }
 }
 
 CSSParseResult
 CSSParserImpl::ParseSingleValueProperty(nsCSSValue& aValue,
-                                        nsCSSPropertyID aPropID)
+                                        nsCSSProperty aPropID)
 {
   if (aPropID == eCSSPropertyExtra_x_none_value) {
     return ParseVariant(aValue, VARIANT_NONE | VARIANT_INHERIT, nullptr);
   }
 
   if (aPropID == eCSSPropertyExtra_x_auto_value) {
     return ParseVariant(aValue, VARIANT_AUTO | VARIANT_INHERIT, nullptr);
   }
@@ -11931,27 +11931,27 @@ BoxPositionMaskToCSSValue(int32_t aMask,
       val = NS_STYLE_IMAGELAYER_POSITION_BOTTOM;
     }
   }
 
   return nsCSSValue(val, eCSSUnit_Enumerated);
 }
 
 bool
-CSSParserImpl::ParseImageLayers(const nsCSSPropertyID aTable[])
+CSSParserImpl::ParseImageLayers(const nsCSSProperty aTable[])
 {
   nsAutoParseCompoundProperty compound(this);
 
   // background-color can only be set once, so it's not a list.
   nsCSSValue color;
 
   // Check first for inherit/initial/unset.
   if (ParseSingleTokenVariant(color, VARIANT_INHERIT, nullptr)) {
     // must be alone
-    for (const nsCSSPropertyID* subprops =
+    for (const nsCSSProperty* subprops =
            nsCSSProps::SubpropertyEntryFor(aTable[nsStyleImageLayers::shorthand]);
          *subprops != eCSSProperty_UNKNOWN; ++subprops) {
       AppendValue(*subprops, color);
     }
     return true;
   }
 
   nsCSSValue image, repeat, attachment, clip, origin, positionX, positionY, size,
@@ -12066,17 +12066,17 @@ CSSParserImpl::IsFunctionTokenValidForIm
       funcName.LowerCaseEqualsLiteral("-webkit-repeating-linear-gradient") ||
       funcName.LowerCaseEqualsLiteral("-webkit-repeating-radial-gradient")));
 }
 
 // Parse one item of the background shorthand property.
 bool
 CSSParserImpl::ParseImageLayersItem(
   CSSParserImpl::ImageLayersShorthandParseState& aState,
-  const nsCSSPropertyID aTable[])
+  const nsCSSProperty aTable[])
 {
   // Fill in the values that the shorthand will set if we don't find
   // other values.
   aState.mImage->mValue.SetNoneValue();
   aState.mAttachment->mValue.SetIntValue(NS_STYLE_IMAGELAYER_ATTACHMENT_SCROLL,
                                          eCSSUnit_Enumerated);
   aState.mClip->mValue.SetIntValue(NS_STYLE_IMAGELAYER_CLIP_BORDER,
                                    eCSSUnit_Enumerated);
@@ -12325,17 +12325,17 @@ CSSParserImpl::ParseImageLayersItem(
   }
 
   return haveSomething;
 }
 
 // This function is very similar to ParseScrollSnapCoordinate,
 // ParseImageLayerPosition, and ParseImageLayersSize.
 bool
-CSSParserImpl::ParseValueList(nsCSSPropertyID aPropID)
+CSSParserImpl::ParseValueList(nsCSSProperty aPropID)
 {
   // aPropID is a single value prop-id
   nsCSSValue value;
   // 'initial', 'inherit' and 'unset' stand alone, no list permitted.
   if (!ParseSingleTokenVariant(value, VARIANT_INHERIT, nullptr)) {
     nsCSSValueList* item = value.SetListValue();
     for (;;) {
       if (ParseSingleValueProperty(item->mValue, aPropID) !=
@@ -12349,17 +12349,17 @@ CSSParserImpl::ParseValueList(nsCSSPrope
       item = item->mNext;
     }
   }
   AppendValue(aPropID, value);
   return true;
 }
 
 bool
-CSSParserImpl::ParseImageLayerRepeat(nsCSSPropertyID aPropID)
+CSSParserImpl::ParseImageLayerRepeat(nsCSSProperty aPropID)
 {
   nsCSSValue value;
   // 'initial', 'inherit' and 'unset' stand alone, no list permitted.
   if (!ParseSingleTokenVariant(value, VARIANT_INHERIT, nullptr)) {
     nsCSSValuePair valuePair;
     if (!ParseImageLayerRepeatValues(valuePair)) {
       return false;
     }
@@ -12400,17 +12400,17 @@ CSSParserImpl::ParseImageLayerRepeatValu
     }
     return true;
   }
 
   return false;
 }
 
 bool
-CSSParserImpl::ParseImageLayerPosition(const nsCSSPropertyID aTable[])
+CSSParserImpl::ParseImageLayerPosition(const nsCSSProperty aTable[])
 {
   // 'initial', 'inherit' and 'unset' stand alone, no list permitted.
   nsCSSValue position;
   if (ParseSingleTokenVariant(position, VARIANT_INHERIT, nullptr)) {
     AppendValue(aTable[nsStyleImageLayers::positionX], position);
     AppendValue(aTable[nsStyleImageLayers::positionY], position);
     return true;
   }
@@ -12440,17 +12440,17 @@ CSSParserImpl::ParseImageLayerPosition(c
     itemY = itemY->mNext;
   }
   AppendValue(aTable[nsStyleImageLayers::positionX], valueX);
   AppendValue(aTable[nsStyleImageLayers::positionY], valueY);
   return true;
 }
 
 bool
-CSSParserImpl::ParseImageLayerPositionCoord(nsCSSPropertyID aPropID, bool aIsHorizontal)
+CSSParserImpl::ParseImageLayerPositionCoord(nsCSSProperty aPropID, bool aIsHorizontal)
 {
   nsCSSValue value;
   // 'initial', 'inherit' and 'unset' stand alone, no list permitted.
   if (!ParseSingleTokenVariant(value, VARIANT_INHERIT, nullptr)) {
     nsCSSValue itemValue;
     if (!ParseImageLayerPositionCoordItem(itemValue, aIsHorizontal)) {
       return false;
     }
@@ -12909,17 +12909,17 @@ CSSParserImpl::ParseImageLayerPositionCo
                "Unexpected units");
 
   return true;
 }
 
 // This function is very similar to ParseScrollSnapCoordinate,
 // ParseImageLayers, and ParseImageLayerPosition.
 bool
-CSSParserImpl::ParseImageLayerSize(nsCSSPropertyID aPropID)
+CSSParserImpl::ParseImageLayerSize(nsCSSProperty aPropID)
 {
   nsCSSValue value;
   // 'initial', 'inherit' and 'unset' stand alone, no list permitted.
   if (!ParseSingleTokenVariant(value, VARIANT_INHERIT, nullptr)) {
     nsCSSValuePair valuePair;
     if (!ParseImageLayerSizeValues(valuePair)) {
       return false;
     }
@@ -13283,17 +13283,17 @@ CSSParserImpl::ParseBorderSpacing()
     nsCSSValue pair;
     pair.SetPairValue(xValue, yValue);
     AppendValue(eCSSProperty_border_spacing, pair);
   }
   return true;
 }
 
 bool
-CSSParserImpl::ParseBorderSide(const nsCSSPropertyID aPropIDs[],
+CSSParserImpl::ParseBorderSide(const nsCSSProperty aPropIDs[],
                                bool aSetAllSides)
 {
   const int32_t numProps = 3;
   nsCSSValue  values[numProps];
 
   int32_t found = ParseChoice(values, aPropIDs, numProps);
   if (found < 1) {
     return false;
@@ -13313,17 +13313,17 @@ CSSParserImpl::ParseBorderSide(const nsC
     // Parsing "border" shorthand; set all four sides to the same thing
     for (int32_t index = 0; index < 4; index++) {
       NS_ASSERTION(numProps == 3, "This code needs updating");
       AppendValue(kBorderWidthIDs[index], values[0]);
       AppendValue(kBorderStyleIDs[index], values[1]);
       AppendValue(kBorderColorIDs[index], values[2]);
     }
 
-    static const nsCSSPropertyID kBorderColorsProps[] = {
+    static const nsCSSProperty kBorderColorsProps[] = {
       eCSSProperty_border_top_colors,
       eCSSProperty_border_right_colors,
       eCSSProperty_border_bottom_colors,
       eCSSProperty_border_left_colors
     };
 
     // Set the other properties that the border shorthand sets to their
     // initial values.
@@ -13366,17 +13366,17 @@ CSSParserImpl::ParseBorderStyle()
 
 bool
 CSSParserImpl::ParseBorderWidth()
 {
   return ParseBoxProperties(kBorderWidthIDs);
 }
 
 bool
-CSSParserImpl::ParseBorderColors(nsCSSPropertyID aProperty)
+CSSParserImpl::ParseBorderColors(nsCSSProperty aProperty)
 {
   nsCSSValue value;
   // 'inherit', 'initial', 'unset' and 'none' are only allowed on their own
   if (!ParseSingleTokenVariant(value, VARIANT_INHERIT | VARIANT_NONE,
                                nullptr)) {
     nsCSSValueList *cur = value.SetListValue();
     for (;;) {
       if (ParseVariant(cur->mValue, VARIANT_COLOR | VARIANT_KEYWORD,
@@ -13654,17 +13654,17 @@ CSSParserImpl::RequireWhitespace()
   // Skip any additional whitespace tokens.
   if (GetToken(true)) {
     UngetToken();
   }
   return true;
 }
 
 bool
-CSSParserImpl::ParseRect(nsCSSPropertyID aPropID)
+CSSParserImpl::ParseRect(nsCSSProperty aPropID)
 {
   nsCSSValue val;
   if (ParseSingleTokenVariant(val, VARIANT_INHERIT | VARIANT_AUTO, nullptr)) {
     AppendValue(aPropID, val);
     return true;
   }
 
   if (! GetToken(true)) {
@@ -13705,17 +13705,17 @@ CSSParserImpl::ParseRect(nsCSSPropertyID
 bool
 CSSParserImpl::ParseColumns()
 {
   // We use a similar "fake value" hack to ParseListStyle, because
   // "auto" is acceptable for both column-count and column-width.
   // If the fake "auto" value is found, and one of the real values isn't,
   // that means the fake auto value is meant for the real value we didn't
   // find.
-  static const nsCSSPropertyID columnIDs[] = {
+  static const nsCSSProperty columnIDs[] = {
     eCSSPropertyExtra_x_auto_value,
     eCSSProperty__moz_column_count,
     eCSSProperty__moz_column_width
   };
   const int32_t numProps = MOZ_ARRAY_LENGTH(columnIDs);
 
   nsCSSValue values[numProps];
   int32_t found = ParseChoice(values, columnIDs, numProps);
@@ -13793,17 +13793,17 @@ CSSParserImpl::ParseContent()
       cur = cur->mNext;
     }
   }
   AppendValue(eCSSProperty_content, value);
   return true;
 }
 
 bool
-CSSParserImpl::ParseCounterData(nsCSSPropertyID aPropID)
+CSSParserImpl::ParseCounterData(nsCSSProperty aPropID)
 {
   static const nsCSSKeyword kCounterDataKTable[] = {
     eCSSKeyword_none,
     eCSSKeyword_UNKNOWN
   };
   nsCSSValue value;
   if (!ParseSingleTokenVariant(value, VARIANT_INHERIT | VARIANT_NONE,
                                nullptr)) {
@@ -13941,17 +13941,17 @@ CSSParserImpl::ParseFont()
   // Indexes into fontIDs[] and values[] arrays.
   const int kFontStyleIndex = 0;
   const int kFontVariantIndex = 1;
   const int kFontWeightIndex = 2;
   const int kFontStretchIndex = 3;
 
   // The order of the initializers here must match the order of the indexes
   // defined above!
-  static const nsCSSPropertyID fontIDs[] = {
+  static const nsCSSProperty fontIDs[] = {
     eCSSProperty_font_style,
     eCSSProperty_font_variant_caps,
     eCSSProperty_font_weight,
     eCSSProperty_font_stretch
   };
 
   const int32_t numProps = MOZ_ARRAY_LENGTH(fontIDs);
   nsCSSValue  values[numProps];
@@ -14990,17 +14990,17 @@ CSSParserImpl::ParseListStyle()
 {
   // 'list-style' can accept 'none' for two different subproperties,
   // 'list-style-type' and 'list-style-image'.  In order to accept
   // 'none' as the value of either but still allow another value for
   // either, we need to ensure that the first 'none' we find gets
   // allocated to a dummy property instead. Since parse function for
   // 'list-style-type' could accept values for 'list-style-position',
   // we put position in front of type.
-  static const nsCSSPropertyID listStyleIDs[] = {
+  static const nsCSSProperty listStyleIDs[] = {
     eCSSPropertyExtra_x_none_value,
     eCSSProperty_list_style_position,
     eCSSProperty_list_style_type,
     eCSSProperty_list_style_image
   };
 
   nsCSSValue values[MOZ_ARRAY_LENGTH(listStyleIDs)];
   int32_t found =
@@ -15056,17 +15056,17 @@ CSSParserImpl::ParseListStyleType(nsCSSV
   }
 
   return false;
 }
 
 bool
 CSSParserImpl::ParseMargin()
 {
-  static const nsCSSPropertyID kMarginSideIDs[] = {
+  static const nsCSSProperty kMarginSideIDs[] = {
     eCSSProperty_margin_top,
     eCSSProperty_margin_right,
     eCSSProperty_margin_bottom,
     eCSSProperty_margin_left
   };
 
   return ParseBoxProperties(kMarginSideIDs);
 }
@@ -15082,17 +15082,17 @@ CSSParserImpl::ParseObjectPosition()
   AppendValue(eCSSProperty_object_position, value);
   return true;
 }
 
 bool
 CSSParserImpl::ParseOutline()
 {
   const int32_t numProps = 3;
-  static const nsCSSPropertyID kOutlineIDs[] = {
+  static const nsCSSProperty kOutlineIDs[] = {
     eCSSProperty_outline_color,
     eCSSProperty_outline_style,
     eCSSProperty_outline_width
   };
 
   nsCSSValue  values[numProps];
   int32_t found = ParseChoice(values, kOutlineIDs, numProps);
   if (found < 1) {
@@ -15142,17 +15142,17 @@ CSSParserImpl::ParseOverflow()
   AppendValue(eCSSProperty_overflow_x, overflowX);
   AppendValue(eCSSProperty_overflow_y, overflowY);
   return true;
 }
 
 bool
 CSSParserImpl::ParsePadding()
 {
-  static const nsCSSPropertyID kPaddingSideIDs[] = {
+  static const nsCSSProperty kPaddingSideIDs[] = {
     eCSSProperty_padding_top,
     eCSSProperty_padding_right,
     eCSSProperty_padding_bottom,
     eCSSProperty_padding_left
   };
 
   return ParseBoxProperties(kPaddingSideIDs);
 }
@@ -15183,17 +15183,17 @@ CSSParserImpl::ParseQuotes()
   }
   AppendValue(eCSSProperty_quotes, value);
   return true;
 }
 
 bool
 CSSParserImpl::ParseTextDecoration()
 {
-  static const nsCSSPropertyID kTextDecorationIDs[] = {
+  static const nsCSSProperty kTextDecorationIDs[] = {
     eCSSProperty_text_decoration_line,
     eCSSProperty_text_decoration_style,
     eCSSProperty_text_decoration_color
   };
   const int32_t numProps = MOZ_ARRAY_LENGTH(kTextDecorationIDs);
   nsCSSValue values[numProps];
 
   int32_t found = ParseChoice(values, kTextDecorationIDs, numProps);
@@ -15219,17 +15219,17 @@ CSSParserImpl::ParseTextDecoration()
     AppendValue(kTextDecorationIDs[index], values[index]);
   }
   return true;
 }
 
 bool
 CSSParserImpl::ParseTextEmphasis()
 {
-  static constexpr nsCSSPropertyID kTextEmphasisIDs[] = {
+  static constexpr nsCSSProperty kTextEmphasisIDs[] = {
     eCSSProperty_text_emphasis_style,
     eCSSProperty_text_emphasis_color
   };
   constexpr int32_t numProps = MOZ_ARRAY_LENGTH(kTextEmphasisIDs);
   nsCSSValue values[numProps];
 
   int32_t found = ParseChoice(values, kTextEmphasisIDs, numProps);
   if (found < 1) {
@@ -16255,17 +16255,17 @@ CSSParserImpl::ParseShapeOutside(nsCSSVa
 }
 
 bool CSSParserImpl::ParseTransformOrigin(bool aPerspective)
 {
   nsCSSValuePair position;
   if (!ParseBoxPositionValues(position, true))
     return false;
 
-  nsCSSPropertyID prop = eCSSProperty_transform_origin;
+  nsCSSProperty prop = eCSSProperty_transform_origin;
   if (aPerspective) {
     prop = eCSSProperty_perspective_origin;
   }
 
   // Unlike many other uses of pairs, this position should always be stored
   // as a pair, even if the values are the same, so it always serializes as
   // a pair, and to keep the computation code simple.
   if (position.mXValue.GetUnit() == eCSSUnit_Inherit ||
@@ -16630,17 +16630,17 @@ AppendValueToList(nsCSSValue& aContainer
     aTail->mNext = entry;
   }
   entry->mValue = aValue;
   return entry;
 }
 
 CSSParserImpl::ParseAnimationOrTransitionShorthandResult
 CSSParserImpl::ParseAnimationOrTransitionShorthand(
-                 const nsCSSPropertyID* aProperties,
+                 const nsCSSProperty* aProperties,
                  const nsCSSValue* aInitialValues,
                  nsCSSValue* aValues,
                  size_t aNumProperties)
 {
   nsCSSValue tempValue;
   // first see if 'inherit', 'initial' or 'unset' is specified.  If one is,
   // it can be the only thing specified, so don't attempt to parse any
   // additional properties
@@ -16726,17 +16726,17 @@ CSSParserImpl::ParseAnimationOrTransitio
   }
 
   return eParseAnimationOrTransitionShorthand_Values;
 }
 
 bool
 CSSParserImpl::ParseTransition()
 {
-  static const nsCSSPropertyID kTransitionProperties[] = {
+  static const nsCSSProperty kTransitionProperties[] = {
     eCSSProperty_transition_duration,
     eCSSProperty_transition_timing_function,
     // Must check 'transition-delay' after 'transition-duration', since
     // that's our assumption about what the spec means for the shorthand
     // syntax (the first time given is the duration, and the second
     // given is the delay).
     eCSSProperty_transition_delay,
     // Must check 'transition-property' after
@@ -16803,17 +16803,17 @@ CSSParserImpl::ParseTransition()
     AppendValue(kTransitionProperties[i], values[i]);
   }
   return true;
 }
 
 bool
 CSSParserImpl::ParseAnimation()
 {
-  static const nsCSSPropertyID kAnimationProperties[] = {
+  static const nsCSSProperty kAnimationProperties[] = {
     eCSSProperty_animation_duration,
     eCSSProperty_animation_timing_function,
     // Must check 'animation-delay' after 'animation-duration', since
     // that's our assumption about what the spec means for the shorthand
     // syntax (the first time given is the duration, and the second
     // given is the delay).
     eCSSProperty_animation_delay,
     eCSSProperty_animation_direction,
@@ -16949,17 +16949,17 @@ CSSParserImpl::ParseShadowItem(nsCSSValu
                             nsCSSProps::kBoxShadowTypeKTable);
   }
 
   aValue.SetArrayValue(val, eCSSUnit_Array);
   return true;
 }
 
 bool
-CSSParserImpl::ParseShadowList(nsCSSPropertyID aProperty)
+CSSParserImpl::ParseShadowList(nsCSSProperty aProperty)
 {
   nsAutoParseCompoundProperty compound(this);
   bool isBoxShadow = aProperty == eCSSProperty_box_shadow;
 
   nsCSSValue value;
   // 'inherit', 'initial', 'unset' and 'none' must be alone
   if (!ParseSingleTokenVariant(value, VARIANT_INHERIT | VARIANT_NONE,
                                nullptr)) {
@@ -17005,17 +17005,17 @@ CSSParserImpl::SetDefaultNamespaceOnSele
   if (mNameSpaceMap) {
     aSelector.SetNameSpace(mNameSpaceMap->FindNameSpaceID(nullptr));
   } else {
     aSelector.SetNameSpace(kNameSpaceID_Unknown); // wildcard
   }
 }
 
 bool
-CSSParserImpl::ParsePaint(nsCSSPropertyID aPropID)
+CSSParserImpl::ParsePaint(nsCSSProperty aPropID)
 {
   nsCSSValue x, y;
 
   if (ParseVariant(x, VARIANT_HC | VARIANT_NONE | VARIANT_URL |
                       VARIANT_OPENTYPE_SVG_KEYWORD,
                    nsCSSProps::kContextPatternKTable) != CSSParseResult::Ok) {
     return false;
   }
@@ -17268,17 +17268,17 @@ CSSParserImpl::ParseScrollSnapType()
     return false;
   }
   AppendValue(eCSSProperty_scroll_snap_type_x, value);
   AppendValue(eCSSProperty_scroll_snap_type_y, value);
   return true;
 }
 
 bool
-CSSParserImpl::ParseScrollSnapPoints(nsCSSValue& aValue, nsCSSPropertyID aPropID)
+CSSParserImpl::ParseScrollSnapPoints(nsCSSValue& aValue, nsCSSProperty aPropID)
 {
   if (ParseSingleTokenVariant(aValue, VARIANT_INHERIT | VARIANT_NONE,
                               nullptr)) {
     return true;
   }
   if (!GetToken(true)) {
     return false;
   }
@@ -17572,17 +17572,17 @@ CSSParserImpl::ParseValueWithVariables(C
     aImpliedCharacters.Append(stack[i]);
   }
 
   *aType = type;
   return true;
 }
 
 bool
-CSSParserImpl::IsValueValidForProperty(const nsCSSPropertyID aPropID,
+CSSParserImpl::IsValueValidForProperty(const nsCSSProperty aPropID,
                                        const nsAString& aPropValue)
 {
   mData.AssertInitialState();
   mTempData.AssertInitialState();
 
   nsCSSScanner scanner(aPropValue, 0);
   css::ErrorReporter reporter(scanner, mSheet, mChildLoader, nullptr);
   InitScanner(scanner, reporter, nullptr, nullptr, nullptr);
@@ -17742,34 +17742,34 @@ nsCSSParser::ParseRule(const nsAString& 
                        nsIPrincipal*           aSheetPrincipal,
                        css::Rule**             aResult)
 {
   return static_cast<CSSParserImpl*>(mImpl)->
     ParseRule(aRule, aSheetURI, aBaseURI, aSheetPrincipal, aResult);
 }
 
 void
-nsCSSParser::ParseProperty(const nsCSSPropertyID aPropID,
+nsCSSParser::ParseProperty(const nsCSSProperty aPropID,
                            const nsAString&    aPropValue,
                            nsIURI*             aSheetURI,
                            nsIURI*             aBaseURI,
                            nsIPrincipal*       aSheetPrincipal,
                            css::Declaration*   aDeclaration,
                            bool*               aChanged,
                            bool                aIsImportant,
                            bool                aIsSVGMode)
 {
   static_cast<CSSParserImpl*>(mImpl)->
     ParseProperty(aPropID, aPropValue, aSheetURI, aBaseURI,
                   aSheetPrincipal, aDeclaration, aChanged,
                   aIsImportant, aIsSVGMode);
 }
 
 void
-nsCSSParser::ParseLonghandProperty(const nsCSSPropertyID aPropID,
+nsCSSParser::ParseLonghandProperty(const nsCSSProperty aPropID,
                                    const nsAString&    aPropValue,
                                    nsIURI*             aSheetURI,
                                    nsIURI*             aBaseURI,
                                    nsIPrincipal*       aSheetPrincipal,
                                    nsCSSValue&         aResult)
 {
   static_cast<CSSParserImpl*>(mImpl)->
     ParseLonghandProperty(aPropID, aPropValue, aSheetURI, aBaseURI,
@@ -17915,18 +17915,18 @@ nsCSSParser::ResolveVariableValue(const 
 {
   return static_cast<CSSParserImpl*>(mImpl)->
     ResolveVariableValue(aPropertyValue, aVariables,
                          aResult, aFirstToken, aLastToken);
 }
 
 void
 nsCSSParser::ParsePropertyWithVariableReferences(
-                                            nsCSSPropertyID aPropertyID,
-                                            nsCSSPropertyID aShorthandPropertyID,
+                                            nsCSSProperty aPropertyID,
+                                            nsCSSProperty aShorthandPropertyID,
                                             const nsAString& aValue,
                                             const CSSVariableValues* aVariables,
                                             nsRuleData* aRuleData,
                                             nsIURI* aDocURL,
                                             nsIURI* aBaseURL,
                                             nsIPrincipal* aDocPrincipal,
                                             CSSStyleSheet* aSheet,
                                             uint32_t aLineNumber,
@@ -17970,17 +17970,17 @@ nsCSSParser::ParseFontFaceDescriptor(nsC
                                      nsCSSValue& aValue)
 {
   return static_cast<CSSParserImpl*>(mImpl)->
     ParseFontFaceDescriptor(aDescID, aBuffer,
                            aSheetURL, aBaseURL, aSheetPrincipal, aValue);
 }
 
 bool
-nsCSSParser::IsValueValidForProperty(const nsCSSPropertyID aPropID,
+nsCSSParser::IsValueValidForProperty(const nsCSSProperty aPropID,
                                      const nsAString&    aPropValue)
 {
   return static_cast<CSSParserImpl*>(mImpl)->
     IsValueValidForProperty(aPropID, aPropValue);
 }
 
 /* static */
 uint8_t
--- a/layout/style/nsCSSParser.h
+++ b/layout/style/nsCSSParser.h
@@ -6,17 +6,17 @@
 /* parsing of CSS stylesheets, based on a token stream from the CSS scanner */
 
 #ifndef nsCSSParser_h___
 #define nsCSSParser_h___
 
 #include "mozilla/Attributes.h"
 #include "mozilla/css/Loader.h"
 
-#include "nsCSSPropertyID.h"
+#include "nsCSSProperty.h"
 #include "nsCSSScanner.h"
 #include "nsCOMPtr.h"
 #include "nsAutoPtr.h"
 #include "nsStringFwd.h"
 #include "nsTArrayForwardDeclare.h"
 
 class nsIPrincipal;
 class nsIURI;
@@ -108,30 +108,30 @@ public:
   // Parse the value of a single CSS property, and add or replace that
   // property in aDeclaration.
   //
   // SVG "mapped attributes" (which correspond directly to CSS
   // properties) are parsed slightly differently from regular CSS; in
   // particular, units may be omitted from <length>.  The 'aIsSVGMode'
   // argument controls this quirk.  Note that this *only* applies to
   // mapped attributes, not inline styles or full style sheets in SVG.
-  void ParseProperty(const nsCSSPropertyID aPropID,
+  void ParseProperty(const nsCSSProperty aPropID,
                      const nsAString&    aPropValue,
                      nsIURI*             aSheetURL,
                      nsIURI*             aBaseURL,
                      nsIPrincipal*       aSheetPrincipal,
                      mozilla::css::Declaration* aDeclaration,
                      bool*               aChanged,
                      bool                aIsImportant,
                      bool                aIsSVGMode = false);
 
   // Same as ParseProperty but returns an nsCSSValue in aResult
   // rather than storing the property in a Declaration.  aPropID
   // must be a longhand property.
-  void ParseLonghandProperty(const nsCSSPropertyID aPropID,
+  void ParseLonghandProperty(const nsCSSProperty aPropID,
                              const nsAString&    aPropValue,
                              nsIURI*             aSheetURL,
                              nsIURI*             aBaseURL,
                              nsIPrincipal*       aSheetPrincipal,
                              nsCSSValue&         aResult);
 
   // Parse the value of a CSS transform property. Returns
   // whether the value was successfully parsed. If
@@ -280,18 +280,18 @@ public:
    * otherwise, aPropertyID will be parsed.  Either way, only aPropertyID,
    * a longhand property, will be copied over to the rule data.
    *
    * If the property cannot be parsed, it will be treated as if 'initial' or
    * 'inherit' were specified, for non-inherited and inherited properties
    * respectively.
    */
   void ParsePropertyWithVariableReferences(
-                                   nsCSSPropertyID aPropertyID,
-                                   nsCSSPropertyID aShorthandPropertyID,
+                                   nsCSSProperty aPropertyID,
+                                   nsCSSProperty aShorthandPropertyID,
                                    const nsAString& aValue,
                                    const mozilla::CSSVariableValues* aVariables,
                                    nsRuleData* aRuleData,
                                    nsIURI* aDocURL,
                                    nsIURI* aBaseURL,
                                    nsIPrincipal* aDocPrincipal,
                                    mozilla::CSSStyleSheet* aSheet,
                                    uint32_t aLineNumber,
@@ -311,17 +311,17 @@ public:
   bool ParseFontFaceDescriptor(nsCSSFontDesc aDescID,
                                const nsAString& aBuffer,
                                nsIURI* aSheetURL,
                                nsIURI* aBaseURL,
                                nsIPrincipal* aSheetPrincipal,
                                nsCSSValue& aValue);
 
   // Check whether a given value can be applied to a property.
-  bool IsValueValidForProperty(const nsCSSPropertyID aPropID,
+  bool IsValueValidForProperty(const nsCSSProperty aPropID,
                                const nsAString&    aPropValue);
 
   // Return the default value to be used for -moz-control-character-visibility,
   // from preferences (cached by our Startup(), so that both nsStyleText and
   // nsRuleNode can have fast access to it).
   static uint8_t ControlCharVisibilityDefault();
 
 protected:
--- a/layout/style/nsCSSPropList.h
+++ b/layout/style/nsCSSPropList.h
@@ -22,17 +22,17 @@
   -. 'name' entries represent a CSS property name and *must* use only
   lowercase characters.
 
   -. 'id' should be the same as 'name' except that all hyphens ('-')
   in 'name' are converted to underscores ('_') in 'id'. For properties
   on a standards track, any '-moz-' prefix is removed in 'id'. This
   lets us do nice things with the macros without having to copy/convert
   strings at runtime.  These are the names used for the enum values of
-  the nsCSSPropertyID enumeration defined in nsCSSProps.h.
+  the nsCSSProperty enumeration defined in nsCSSProps.h.
 
   -. 'method' is designed to be as input for CSS2Properties and similar
   callers.  It must always be the same as 'name' except it must use
   InterCaps and all hyphens ('-') must be removed.  Callers using this
   parameter must also define the CSS_PROP_PUBLIC_OR_PRIVATE(publicname_,
   privatename_) macro to yield either publicname_ or privatename_.
   The names differ in that publicname_ has Moz prefixes where they are
   used, and also in CssFloat vs. Float.  The caller's choice depends on
new file mode 100644
--- /dev/null
+++ b/layout/style/nsCSSProperty.h
@@ -0,0 +1,115 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/* enum types for CSS properties and their values */
+ 
+#ifndef nsCSSProperty_h___
+#define nsCSSProperty_h___
+
+#include <nsHashKeys.h>
+
+/*
+   Declare the enum list using the magic of preprocessing
+   enum values are "eCSSProperty_foo" (where foo is the property)
+
+   To change the list of properties, see nsCSSPropList.h
+
+ */
+enum nsCSSProperty {
+  eCSSProperty_UNKNOWN = -1,
+
+  #define CSS_PROP(name_, id_, method_, flags_, pref_, parsevariant_, \
+                   kwtable_, stylestruct_, stylestructoffset_, animtype_) \
+    eCSSProperty_##id_,
+  #define CSS_PROP_LIST_INCLUDE_LOGICAL
+  #include "nsCSSPropList.h"
+  #undef CSS_PROP_LIST_INCLUDE_LOGICAL
+  #undef CSS_PROP
+
+  eCSSProperty_COUNT_no_shorthands,
+  // Make the count continue where it left off:
+  eCSSProperty_COUNT_DUMMY = eCSSProperty_COUNT_no_shorthands - 1,
+
+  #define CSS_PROP_SHORTHAND(name_, id_, method_, flags_, pref_) \
+    eCSSProperty_##id_,
+  #include "nsCSSPropList.h"
+  #undef CSS_PROP_SHORTHAND
+
+  eCSSProperty_COUNT,
+  // Make the count continue where it left off:
+  eCSSProperty_COUNT_DUMMY2 = eCSSProperty_COUNT - 1,
+
+  #define CSS_PROP_ALIAS(aliasname_, id_, method_, pref_) \
+    eCSSPropertyAlias_##method_,
+  #include "nsCSSPropAliasList.h"
+  #undef CSS_PROP_ALIAS
+
+  eCSSProperty_COUNT_with_aliases,
+  // Make the count continue where it left off:
+  eCSSProperty_COUNT_DUMMY3 = eCSSProperty_COUNT_with_aliases - 1,
+
+  // Some of the values below could probably overlap with each other
+  // if we had a need for them to do so.
+
+  // Extra values for use in the values of the 'transition-property'
+  // property.
+  eCSSPropertyExtra_no_properties,
+  eCSSPropertyExtra_all_properties,
+
+  // Extra dummy values for nsCSSParser internal use.
+  eCSSPropertyExtra_x_none_value,
+  eCSSPropertyExtra_x_auto_value,
+
+  // Extra value to represent custom properties (--*).
+  eCSSPropertyExtra_variable
+};
+
+namespace mozilla {
+
+template<>
+inline PLDHashNumber
+Hash<nsCSSProperty>(const nsCSSProperty& aValue)
+{
+  return uint32_t(aValue);
+}
+
+} // namespace mozilla
+
+// The "descriptors" that can appear in a @font-face rule.
+// They have the syntax of properties but different value rules.
+enum nsCSSFontDesc {
+  eCSSFontDesc_UNKNOWN = -1,
+#define CSS_FONT_DESC(name_, method_) eCSSFontDesc_##method_,
+#include "nsCSSFontDescList.h"
+#undef CSS_FONT_DESC
+  eCSSFontDesc_COUNT
+};
+
+// The "descriptors" that can appear in a @counter-style rule.
+// They have the syntax of properties but different value rules.
+enum nsCSSCounterDesc {
+  eCSSCounterDesc_UNKNOWN = -1,
+#define CSS_COUNTER_DESC(name_, method_) eCSSCounterDesc_##method_,
+#include "nsCSSCounterDescList.h"
+#undef CSS_COUNTER_DESC
+  eCSSCounterDesc_COUNT
+};
+
+enum nsCSSPropertyLogicalGroup {
+  eCSSPropertyLogicalGroup_UNKNOWN = -1,
+#define CSS_PROP_LOGICAL_GROUP_AXIS(name_) \
+  eCSSPropertyLogicalGroup_##name_,
+#define CSS_PROP_LOGICAL_GROUP_BOX(name_) \
+  eCSSPropertyLogicalGroup_##name_,
+#define CSS_PROP_LOGICAL_GROUP_SHORTHAND(name_) \
+  eCSSPropertyLogicalGroup_##name_,
+#include "nsCSSPropLogicalGroupList.h"
+#undef CSS_PROP_LOGICAL_GROUP_SHORTHAND
+#undef CSS_PROP_LOGICAL_GROUP_BOX
+#undef CSS_PROP_LOGICAL_GROUP_AXIS
+  eCSSPropertyLogicalGroup_COUNT
+};
+
+#endif /* nsCSSProperty_h___ */
deleted file mode 100644
--- a/layout/style/nsCSSPropertyID.h
+++ /dev/null
@@ -1,115 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-/* enum types for CSS properties and their values */
- 
-#ifndef nsCSSPropertyID_h___
-#define nsCSSPropertyID_h___
-
-#include <nsHashKeys.h>
-
-/*
-   Declare the enum list using the magic of preprocessing
-   enum values are "eCSSProperty_foo" (where foo is the property)
-
-   To change the list of properties, see nsCSSPropList.h
-
- */
-enum nsCSSPropertyID {
-  eCSSProperty_UNKNOWN = -1,
-
-  #define CSS_PROP(name_, id_, method_, flags_, pref_, parsevariant_, \
-                   kwtable_, stylestruct_, stylestructoffset_, animtype_) \
-    eCSSProperty_##id_,
-  #define CSS_PROP_LIST_INCLUDE_LOGICAL
-  #include "nsCSSPropList.h"
-  #undef CSS_PROP_LIST_INCLUDE_LOGICAL
-  #undef CSS_PROP
-
-  eCSSProperty_COUNT_no_shorthands,
-  // Make the count continue where it left off:
-  eCSSProperty_COUNT_DUMMY = eCSSProperty_COUNT_no_shorthands - 1,
-
-  #define CSS_PROP_SHORTHAND(name_, id_, method_, flags_, pref_) \
-    eCSSProperty_##id_,
-  #include "nsCSSPropList.h"
-  #undef CSS_PROP_SHORTHAND
-
-  eCSSProperty_COUNT,
-  // Make the count continue where it left off:
-  eCSSProperty_COUNT_DUMMY2 = eCSSProperty_COUNT - 1,
-
-  #define CSS_PROP_ALIAS(aliasname_, id_, method_, pref_) \
-    eCSSPropertyAlias_##method_,
-  #include "nsCSSPropAliasList.h"
-  #undef CSS_PROP_ALIAS
-
-  eCSSProperty_COUNT_with_aliases,
-  // Make the count continue where it left off:
-  eCSSProperty_COUNT_DUMMY3 = eCSSProperty_COUNT_with_aliases - 1,
-
-  // Some of the values below could probably overlap with each other
-  // if we had a need for them to do so.
-
-  // Extra values for use in the values of the 'transition-property'
-  // property.
-  eCSSPropertyExtra_no_properties,
-  eCSSPropertyExtra_all_properties,
-
-  // Extra dummy values for nsCSSParser internal use.
-  eCSSPropertyExtra_x_none_value,
-  eCSSPropertyExtra_x_auto_value,
-
-  // Extra value to represent custom properties (--*).
-  eCSSPropertyExtra_variable
-};
-
-namespace mozilla {
-
-template<>
-inline PLDHashNumber
-Hash<nsCSSPropertyID>(const nsCSSPropertyID& aValue)
-{
-  return uint32_t(aValue);
-}
-
-} // namespace mozilla
-
-// The "descriptors" that can appear in a @font-face rule.
-// They have the syntax of properties but different value rules.
-enum nsCSSFontDesc {
-  eCSSFontDesc_UNKNOWN = -1,
-#define CSS_FONT_DESC(name_, method_) eCSSFontDesc_##method_,
-#include "nsCSSFontDescList.h"
-#undef CSS_FONT_DESC
-  eCSSFontDesc_COUNT
-};
-
-// The "descriptors" that can appear in a @counter-style rule.
-// They have the syntax of properties but different value rules.
-enum nsCSSCounterDesc {
-  eCSSCounterDesc_UNKNOWN = -1,
-#define CSS_COUNTER_DESC(name_, method_) eCSSCounterDesc_##method_,
-#include "nsCSSCounterDescList.h"
-#undef CSS_COUNTER_DESC
-  eCSSCounterDesc_COUNT
-};
-
-enum nsCSSPropertyLogicalGroup {
-  eCSSPropertyLogicalGroup_UNKNOWN = -1,
-#define CSS_PROP_LOGICAL_GROUP_AXIS(name_) \
-  eCSSPropertyLogicalGroup_##name_,
-#define CSS_PROP_LOGICAL_GROUP_BOX(name_) \
-  eCSSPropertyLogicalGroup_##name_,
-#define CSS_PROP_LOGICAL_GROUP_SHORTHAND(name_) \
-  eCSSPropertyLogicalGroup_##name_,
-#include "nsCSSPropLogicalGroupList.h"
-#undef CSS_PROP_LOGICAL_GROUP_SHORTHAND
-#undef CSS_PROP_LOGICAL_GROUP_BOX
-#undef CSS_PROP_LOGICAL_GROUP_AXIS
-  eCSSPropertyLogicalGroup_COUNT
-};
-
-#endif /* nsCSSPropertyID_h___ */
deleted file mode 100644
--- a/layout/style/nsCSSPropertyIDSet.h
+++ /dev/null
@@ -1,98 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-/* bit vectors for sets of CSS properties */
-
-#ifndef nsCSSPropertyIDSet_h__
-#define nsCSSPropertyIDSet_h__
-
-#include "mozilla/ArrayUtils.h"
-#include "mozilla/PodOperations.h"
-
-#include "nsCSSPropertyID.h"
-#include <limits.h> // for CHAR_BIT
-
-/**
- * nsCSSPropertyIDSet maintains a set of non-shorthand CSS properties.  In
- * other words, for each longhand CSS property we support, it has a bit
- * for whether that property is in the set.
- */
-class nsCSSPropertyIDSet {
-public:
-    nsCSSPropertyIDSet() { Empty(); }
-    // auto-generated copy-constructor OK
-
-    void AssertInSetRange(nsCSSPropertyID aProperty) const {
-        NS_ASSERTION(0 <= aProperty &&
-                     aProperty < eCSSProperty_COUNT_no_shorthands,
-                     "out of bounds");
-    }
-
-    // Conversion of aProperty to |size_t| after AssertInSetRange
-    // lets the compiler generate significantly tighter code.
-
-    void AddProperty(nsCSSPropertyID aProperty) {
-        AssertInSetRange(aProperty);
-        size_t p = aProperty;
-        mProperties[p / kBitsInChunk] |=
-          property_set_type(1) << (p % kBitsInChunk);
-    }
-
-    void RemoveProperty(nsCSSPropertyID aProperty) {
-        AssertInSetRange(aProperty);
-        size_t p = aProperty;
-        mProperties[p / kBitsInChunk] &=
-            ~(property_set_type(1) << (p % kBitsInChunk));
-    }
-
-    bool HasProperty(nsCSSPropertyID aProperty) const {
-        AssertInSetRange(aProperty);
-        size_t p = aProperty;
-        return (mProperties[p / kBitsInChunk] &
-                (property_set_type(1) << (p % kBitsInChunk))) != 0;
-    }
-
-    void Empty() {
-        memset(mProperties, 0, sizeof(mProperties));
-    }
-
-    void AssertIsEmpty(const char* aText) const {
-        for (size_t i = 0; i < mozilla::ArrayLength(mProperties); ++i) {
-            NS_ASSERTION(mProperties[i] == 0, aText);
-        }
-    }
-
-    bool Equals(const nsCSSPropertyIDSet& aOther) const {
-      return mozilla::PodEqual(mProperties, aOther.mProperties);
-    }
-
-private:
-    typedef unsigned long property_set_type;
-public:
-    // number of bits in |property_set_type|.
-    static const size_t kBitsInChunk = sizeof(property_set_type)*CHAR_BIT;
-    // number of |property_set_type|s in the set
-    static const size_t kChunkCount =
-        (eCSSProperty_COUNT_no_shorthands + kBitsInChunk - 1) / kBitsInChunk;
-
-    /*
-     * For fast enumeration of all the bits that are set, callers can
-     * check each chunk against zero (since in normal cases few bits are
-     * likely to be set).
-     */
-    bool HasPropertyInChunk(size_t aChunk) const {
-        return mProperties[aChunk] != 0;
-    }
-    bool HasPropertyAt(size_t aChunk, size_t aBit) const {
-        return (mProperties[aChunk] & (property_set_type(1) << aBit)) != 0;
-    }
-    static nsCSSPropertyID CSSPropertyAt(size_t aChunk, size_t aBit) {
-        return nsCSSPropertyID(aChunk * kBitsInChunk + aBit);
-    }
-
-private:
-    property_set_type mProperties[kChunkCount];
-};
-
-#endif /* !defined(nsCSSPropertyIDSet_h__) */
new file mode 100644
--- /dev/null
+++ b/layout/style/nsCSSPropertySet.h
@@ -0,0 +1,98 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/* bit vectors for sets of CSS properties */
+
+#ifndef nsCSSPropertySet_h__
+#define nsCSSPropertySet_h__
+
+#include "mozilla/ArrayUtils.h"
+#include "mozilla/PodOperations.h"
+
+#include "nsCSSProperty.h"
+#include <limits.h> // for CHAR_BIT
+
+/**
+ * nsCSSPropertySet maintains a set of non-shorthand CSS properties.  In
+ * other words, for each longhand CSS property we support, it has a bit
+ * for whether that property is in the set.
+ */
+class nsCSSPropertySet {
+public:
+    nsCSSPropertySet() { Empty(); }
+    // auto-generated copy-constructor OK
+
+    void AssertInSetRange(nsCSSProperty aProperty) const {
+        NS_ASSERTION(0 <= aProperty &&
+                     aProperty < eCSSProperty_COUNT_no_shorthands,
+                     "out of bounds");
+    }
+
+    // Conversion of aProperty to |size_t| after AssertInSetRange
+    // lets the compiler generate significantly tighter code.
+
+    void AddProperty(nsCSSProperty aProperty) {
+        AssertInSetRange(aProperty);
+        size_t p = aProperty;
+        mProperties[p / kBitsInChunk] |=
+          property_set_type(1) << (p % kBitsInChunk);
+    }
+
+    void RemoveProperty(nsCSSProperty aProperty) {
+        AssertInSetRange(aProperty);
+        size_t p = aProperty;
+        mProperties[p / kBitsInChunk] &=
+            ~(property_set_type(1) << (p % kBitsInChunk));
+    }
+
+    bool HasProperty(nsCSSProperty aProperty) const {
+        AssertInSetRange(aProperty);
+        size_t p = aProperty;
+        return (mProperties[p / kBitsInChunk] &
+                (property_set_type(1) << (p % kBitsInChunk))) != 0;
+    }
+
+    void Empty() {
+        memset(mProperties, 0, sizeof(mProperties));
+    }
+
+    void AssertIsEmpty(const char* aText) const {
+        for (size_t i = 0; i < mozilla::ArrayLength(mProperties); ++i) {
+            NS_ASSERTION(mProperties[i] == 0, aText);
+        }
+    }
+
+    bool Equals(const nsCSSPropertySet& aOther) const {
+      return mozilla::PodEqual(mProperties, aOther.mProperties);
+    }
+
+private:
+    typedef unsigned long property_set_type;
+public:
+    // number of bits in |property_set_type|.
+    static const size_t kBitsInChunk = sizeof(property_set_type)*CHAR_BIT;
+    // number of |property_set_type|s in the set
+    static const size_t kChunkCount =
+        (eCSSProperty_COUNT_no_shorthands + kBitsInChunk - 1) / kBitsInChunk;
+
+    /*
+     * For fast enumeration of all the bits that are set, callers can
+     * check each chunk against zero (since in normal cases few bits are
+     * likely to be set).
+     */
+    bool HasPropertyInChunk(size_t aChunk) const {
+        return mProperties[aChunk] != 0;
+    }
+    bool HasPropertyAt(size_t aChunk, size_t aBit) const {
+        return (mProperties[aChunk] & (property_set_type(1) << aBit)) != 0;
+    }
+    static nsCSSProperty CSSPropertyAt(size_t aChunk, size_t aBit) {
+        return nsCSSProperty(aChunk * kBitsInChunk + aBit);
+    }
+
+private:
+    property_set_type mProperties[kChunkCount];
+};
+
+#endif /* !defined(nsCSSPropertySet_h__) */
--- a/layout/style/nsCSSProps.cpp
+++ b/layout/style/nsCSSProps.cpp
@@ -76,21 +76,21 @@ const char* const kCSSRawProperties[eCSS
 
 using namespace mozilla;
 
 static int32_t gPropertyTableRefCount;
 static nsStaticCaseInsensitiveNameTable* gPropertyTable;
 static nsStaticCaseInsensitiveNameTable* gFontDescTable;
 static nsStaticCaseInsensitiveNameTable* gCounterDescTable;
 static nsStaticCaseInsensitiveNameTable* gPredefinedCounterStyleTable;
-static nsDataHashtable<nsCStringHashKey,nsCSSPropertyID>* gPropertyIDLNameTable;
-
-/* static */ nsCSSPropertyID *
+static nsDataHashtable<nsCStringHashKey,nsCSSProperty>* gPropertyIDLNameTable;
+
+/* static */ nsCSSProperty *
   nsCSSProps::gShorthandsContainingTable[eCSSProperty_COUNT_no_shorthands];
-/* static */ nsCSSPropertyID* nsCSSProps::gShorthandsContainingPool = nullptr;
+/* static */ nsCSSProperty* nsCSSProps::gShorthandsContainingPool = nullptr;
 
 static const char* const kCSSRawFontDescs[] = {
 #define CSS_FONT_DESC(name_, method_) #name_,
 #include "nsCSSFontDescList.h"
 #undef CSS_FONT_DESC
 };
 
 static const char* const kCSSRawCounterDescs[] = {
@@ -123,17 +123,17 @@ static const char* const kCSSRawPredefin
   // 7.1.3 Chinese
   "simp-chinese-informal", "simp-chinese-formal",
   "trad-chinese-informal", "trad-chinese-formal", "cjk-ideographic",
   // 7.2 Ethiopic Numeric Counter Style
   "ethiopic-numeric"
 };
 
 struct PropertyAndCount {
-  nsCSSPropertyID property;
+  nsCSSProperty property;
   uint32_t count;
 };
 
 static int
 SortPropertyAndCount(const void* s1, const void* s2, void *closure)
 {
   const PropertyAndCount *pc1 = static_cast<const PropertyAndCount*>(s1);
   const PropertyAndCount *pc2 = static_cast<const PropertyAndCount*>(s2);
@@ -146,17 +146,17 @@ SortPropertyAndCount(const void* s1, con
 
 // We need eCSSAliasCount so we can make gAliases nonzero size when there
 // are no aliases.
 enum {
   eCSSAliasCount = eCSSProperty_COUNT_with_aliases - eCSSProperty_COUNT
 };
 
 // The names are in kCSSRawProperties.
-static nsCSSPropertyID gAliases[eCSSAliasCount != 0 ? eCSSAliasCount : 1] = {
+static nsCSSProperty gAliases[eCSSAliasCount != 0 ? eCSSAliasCount : 1] = {
 #define CSS_PROP_ALIAS(aliasname_, propid_, aliasmethod_, pref_)  \
   eCSSProperty_##propid_ ,
 #include "nsCSSPropAliasList.h"
 #undef CSS_PROP_ALIAS
 };
 
 nsStaticCaseInsensitiveNameTable*
 CreateStaticTable(const char* const aRawTable[], int32_t aLength)
@@ -187,20 +187,20 @@ nsCSSProps::AddRefTable(void)
         kCSSRawProperties, eCSSProperty_COUNT_with_aliases);
     gFontDescTable = CreateStaticTable(kCSSRawFontDescs, eCSSFontDesc_COUNT);
     gCounterDescTable = CreateStaticTable(
         kCSSRawCounterDescs, eCSSCounterDesc_COUNT);
     gPredefinedCounterStyleTable = CreateStaticTable(
         kCSSRawPredefinedCounterStyles,
         ArrayLength(kCSSRawPredefinedCounterStyles));
 
-    gPropertyIDLNameTable = new nsDataHashtable<nsCStringHashKey,nsCSSPropertyID>;
-    for (nsCSSPropertyID p = nsCSSPropertyID(0);
+    gPropertyIDLNameTable = new nsDataHashtable<nsCStringHashKey,nsCSSProperty>;
+    for (nsCSSProperty p = nsCSSProperty(0);
          size_t(p) < ArrayLength(kIDLNameTable);
-         p = nsCSSPropertyID(p + 1)) {
+         p = nsCSSProperty(p + 1)) {
       if (kIDLNameTable[p]) {
         gPropertyIDLNameTable->Put(nsDependentCString(kIDLNameTable[p]), p);
       }
     }
 
     BuildShorthandsContainingTable();
 
     static bool prefObserversInited = false;
@@ -238,65 +238,65 @@ nsCSSProps::AddRefTable(void)
     {
       // Assert that if CSS_PROPERTY_ENABLED_IN_UA_SHEETS or
       // CSS_PROPERTY_ENABLED_IN_CHROME is used on a shorthand property
       // that all of its component longhands also have the flag.
       static uint32_t flagsToCheck[] = {
         CSS_PROPERTY_ENABLED_IN_UA_SHEETS,
         CSS_PROPERTY_ENABLED_IN_CHROME
       };
-      for (nsCSSPropertyID shorthand = eCSSProperty_COUNT_no_shorthands;
+      for (nsCSSProperty shorthand = eCSSProperty_COUNT_no_shorthands;
            shorthand < eCSSProperty_COUNT;
-           shorthand = nsCSSPropertyID(shorthand + 1)) {
+           shorthand = nsCSSProperty(shorthand + 1)) {
         for (size_t i = 0; i < ArrayLength(flagsToCheck); i++) {
           uint32_t flag = flagsToCheck[i];
           if (!nsCSSProps::PropHasFlags(shorthand, flag)) {
             continue;
           }
-          for (const nsCSSPropertyID* p =
+          for (const nsCSSProperty* p =
                  nsCSSProps::SubpropertyEntryFor(shorthand);
                *p != eCSSProperty_UNKNOWN;
                ++p) {
             MOZ_ASSERT(nsCSSProps::PropHasFlags(*p, flag),
                        "all subproperties of a property with a "
                        "CSS_PROPERTY_ENABLED_* flag must also have "
                        "the flag");
           }
         }
       }
 
       // Assert that CSS_PROPERTY_INTERNAL is used on properties in
       // #ifndef CSS_PROP_LIST_EXCLUDE_INTERNAL sections of nsCSSPropList.h
       // and on no others.
-      static nsCSSPropertyID nonInternalProperties[] = {
+      static nsCSSProperty nonInternalProperties[] = {
         #define CSS_PROP(name_, id_, ...)           eCSSProperty_##id_,
         #define CSS_PROP_SHORTHAND(name_, id_, ...) eCSSProperty_##id_,
         #define CSS_PROP_LIST_INCLUDE_LOGICAL
         #define CSS_PROP_LIST_EXCLUDE_INTERNAL
         #include "nsCSSPropList.h"
         #undef CSS_PROP_LIST_EXCLUDE_INTERNAL
         #undef CSS_PROP_LIST_INCLUDE_LOGICAL
         #undef CSS_PROP_SHORTHAND
         #undef CSS_PROP
       };
       MOZ_ASSERT(ArrayLength(nonInternalProperties) <= eCSSProperty_COUNT);
 
       bool found[eCSSProperty_COUNT];
       PodArrayZero(found);
-      for (nsCSSPropertyID p : nonInternalProperties) {
+      for (nsCSSProperty p : nonInternalProperties) {
         MOZ_ASSERT(!nsCSSProps::PropHasFlags(p, CSS_PROPERTY_INTERNAL),
                    "properties defined outside of #ifndef "
                    "CSS_PROP_LIST_EXCLUDE_INTERNAL sections must not have "
                    "the CSS_PROPERTY_INTERNAL flag");
         found[p] = true;
       }
 
       for (size_t i = 0; i < ArrayLength(found); ++i) {
         if (!found[i]) {
-          auto p = static_cast<nsCSSPropertyID>(i);
+          auto p = static_cast<nsCSSProperty>(i);
           MOZ_ASSERT(nsCSSProps::PropHasFlags(p, CSS_PROPERTY_INTERNAL),
                      "properties defined in #ifndef "
                      "CSS_PROP_LIST_EXCLUDE_INTERNAL sections must have "
                      "the CSS_PROPERTY_INTERNAL flag");
         }
       }
     }
 #endif
@@ -307,64 +307,64 @@ nsCSSProps::AddRefTable(void)
 
 bool
 nsCSSProps::BuildShorthandsContainingTable()
 {
   uint32_t occurrenceCounts[eCSSProperty_COUNT_no_shorthands];
   memset(occurrenceCounts, 0, sizeof(occurrenceCounts));
   PropertyAndCount subpropCounts[eCSSProperty_COUNT -
                                    eCSSProperty_COUNT_no_shorthands];
-  for (nsCSSPropertyID shorthand = eCSSProperty_COUNT_no_shorthands;
+  for (nsCSSProperty shorthand = eCSSProperty_COUNT_no_shorthands;
        shorthand < eCSSProperty_COUNT;
-       shorthand = nsCSSPropertyID(shorthand + 1)) {
+       shorthand = nsCSSProperty(shorthand + 1)) {
 #ifdef DEBUG_SHORTHANDS_CONTAINING
     printf("Considering shorthand property '%s'.\n",
            nsCSSProps::GetStringValue(shorthand).get());
 #endif
     PropertyAndCount &subpropCountsEntry =
       subpropCounts[shorthand - eCSSProperty_COUNT_no_shorthands];
     subpropCountsEntry.property = shorthand;
     subpropCountsEntry.count = 0;
     if (nsCSSProps::PropHasFlags(shorthand, CSS_PROPERTY_IS_ALIAS)) {
       // Don't put shorthands that are acting as aliases in the
       // shorthands-containing lists.
       continue;
     }
-    for (const nsCSSPropertyID* subprops = SubpropertyEntryFor(shorthand);
+    for (const nsCSSProperty* subprops = SubpropertyEntryFor(shorthand);
          *subprops != eCSSProperty_UNKNOWN;
          ++subprops) {
       MOZ_ASSERT(0 <= *subprops && *subprops < eCSSProperty_COUNT_no_shorthands,
                  "subproperty must be a longhand");
       ++occurrenceCounts[*subprops];
       ++subpropCountsEntry.count;
     }
   }
 
   uint32_t poolEntries = 0;
-  for (nsCSSPropertyID longhand = nsCSSPropertyID(0);
+  for (nsCSSProperty longhand = nsCSSProperty(0);
        longhand < eCSSProperty_COUNT_no_shorthands;
-       longhand = nsCSSPropertyID(longhand + 1)) {
+       longhand = nsCSSProperty(longhand + 1)) {
     uint32_t count = occurrenceCounts[longhand];
     if (count > 0)
       // leave room for terminator
       poolEntries += count + 1;
   }
 
-  gShorthandsContainingPool = new nsCSSPropertyID[poolEntries];
+  gShorthandsContainingPool = new nsCSSProperty[poolEntries];
   if (!gShorthandsContainingPool)
     return false;
 
   // Initialize all entries to point to their null-terminator.
   {
-    nsCSSPropertyID *poolCursor = gShorthandsContainingPool - 1;
-    nsCSSPropertyID *lastTerminator =
+    nsCSSProperty *poolCursor = gShorthandsContainingPool - 1;
+    nsCSSProperty *lastTerminator =
       gShorthandsContainingPool + poolEntries - 1;
-    for (nsCSSPropertyID longhand = nsCSSPropertyID(0);
+    for (nsCSSProperty longhand = nsCSSProperty(0);
          longhand < eCSSProperty_COUNT_no_shorthands;
-         longhand = nsCSSPropertyID(longhand + 1)) {
+         longhand = nsCSSProperty(longhand + 1)) {
       uint32_t count = occurrenceCounts[longhand];
       if (count > 0) {
         poolCursor += count + 1;
         gShorthandsContainingTable[longhand] = poolCursor;
         *poolCursor = eCSSProperty_UNKNOWN;
       } else {
         gShorthandsContainingTable[longhand] = lastTerminator;
       }
@@ -388,74 +388,74 @@ nsCSSProps::BuildShorthandsContainingTab
            nsCSSProps::GetStringValue(shorthandAndCount->property).get());
 #endif
     if (nsCSSProps::PropHasFlags(shorthandAndCount->property,
                                  CSS_PROPERTY_IS_ALIAS)) {
       // Don't put shorthands that are acting as aliases in the
       // shorthands-containing lists.
       continue;
     }
-    for (const nsCSSPropertyID* subprops =
+    for (const nsCSSProperty* subprops =
            SubpropertyEntryFor(shorthandAndCount->property);
          *subprops != eCSSProperty_UNKNOWN;
          ++subprops) {
       *(--gShorthandsContainingTable[*subprops]) = shorthandAndCount->property;
     }
   }
 
 #ifdef DEBUG_SHORTHANDS_CONTAINING
-  for (nsCSSPropertyID longhand = nsCSSPropertyID(0);
+  for (nsCSSProperty longhand = nsCSSProperty(0);
        longhand < eCSSProperty_COUNT_no_shorthands;
-       longhand = nsCSSPropertyID(longhand + 1)) {
+       longhand = nsCSSProperty(longhand + 1)) {
     printf("Property %s is in %d shorthands.\n",
            nsCSSProps::GetStringValue(longhand).get(),
            occurrenceCounts[longhand]);
-    for (const nsCSSPropertyID *shorthands = ShorthandsContaining(longhand);
+    for (const nsCSSProperty *shorthands = ShorthandsContaining(longhand);
          *shorthands != eCSSProperty_UNKNOWN;
          ++shorthands) {
       printf("  %s\n", nsCSSProps::GetStringValue(*shorthands).get());
     }
   }
 #endif
 
 #ifdef DEBUG
   // Verify that all values that should be are present.
-  for (nsCSSPropertyID shorthand = eCSSProperty_COUNT_no_shorthands;
+  for (nsCSSProperty shorthand = eCSSProperty_COUNT_no_shorthands;
        shorthand < eCSSProperty_COUNT;
-       shorthand = nsCSSPropertyID(shorthand + 1)) {
+       shorthand = nsCSSProperty(shorthand + 1)) {
     if (nsCSSProps::PropHasFlags(shorthand, CSS_PROPERTY_IS_ALIAS)) {
       // Don't put shorthands that are acting as aliases in the
       // shorthands-containing lists.
       continue;
     }
-    for (const nsCSSPropertyID* subprops = SubpropertyEntryFor(shorthand);
+    for (const nsCSSProperty* subprops = SubpropertyEntryFor(shorthand);
          *subprops != eCSSProperty_UNKNOWN;
          ++subprops) {
       uint32_t count = 0;
-      for (const nsCSSPropertyID *shcont = ShorthandsContaining(*subprops);
+      for (const nsCSSProperty *shcont = ShorthandsContaining(*subprops);
            *shcont != eCSSProperty_UNKNOWN;
            ++shcont) {
         if (*shcont == shorthand)
           ++count;
       }
       MOZ_ASSERT(count == 1,
                  "subproperty of shorthand should have shorthand"
                  " in its ShorthandsContaining() table");
     }
   }
 
   // Verify that there are no extra values
-  for (nsCSSPropertyID longhand = nsCSSPropertyID(0);
+  for (nsCSSProperty longhand = nsCSSProperty(0);
        longhand < eCSSProperty_COUNT_no_shorthands;
-       longhand = nsCSSPropertyID(longhand + 1)) {
-    for (const nsCSSPropertyID *shorthands = ShorthandsContaining(longhand);
+       longhand = nsCSSProperty(longhand + 1)) {
+    for (const nsCSSProperty *shorthands = ShorthandsContaining(longhand);
          *shorthands != eCSSProperty_UNKNOWN;
          ++shorthands) {
       uint32_t count = 0;
-      for (const nsCSSPropertyID* subprops = SubpropertyEntryFor(*shorthands);
+      for (const nsCSSProperty* subprops = SubpropertyEntryFor(*shorthands);
            *subprops != eCSSProperty_UNKNOWN;
            ++subprops) {
         if (*subprops == longhand)
           ++count;
       }
       MOZ_ASSERT(count == 1,
                  "longhand should be in subproperty table of "
                  "property in its ShorthandsContaining() table");
@@ -486,17 +486,17 @@ nsCSSProps::ReleaseTable(void)
     gPropertyIDLNameTable = nullptr;
 
     delete [] gShorthandsContainingPool;
     gShorthandsContainingPool = nullptr;
   }
 }
 
 /* static */ bool
-nsCSSProps::IsInherited(nsCSSPropertyID aProperty)
+nsCSSProps::IsInherited(nsCSSProperty aProperty)
 {
   MOZ_ASSERT(!IsShorthand(aProperty));
 
   nsStyleStructID sid = kSIDTable[aProperty];
   return nsCachedStyleData::IsInherited(sid);
 }
 
 /* static */ bool
@@ -509,28 +509,28 @@ nsCSSProps::IsCustomPropertyName(const n
 
 /* static */ bool
 nsCSSProps::IsCustomPropertyName(const nsAString& aProperty)
 {
   return aProperty.Length() >= CSS_CUSTOM_NAME_PREFIX_LENGTH &&
          StringBeginsWith(aProperty, NS_LITERAL_STRING("--"));
 }
 
-nsCSSPropertyID
+nsCSSProperty
 nsCSSProps::LookupProperty(const nsACString& aProperty,
                            EnabledState aEnabled)
 {
   MOZ_ASSERT(gPropertyTable, "no lookup table, needs addref");
 
   if (nsLayoutUtils::CSSVariablesEnabled() &&
       IsCustomPropertyName(aProperty)) {
     return eCSSPropertyExtra_variable;
   }
 
-  nsCSSPropertyID res = nsCSSPropertyID(gPropertyTable->Lookup(aProperty));
+  nsCSSProperty res = nsCSSProperty(gPropertyTable->Lookup(aProperty));
   if (MOZ_LIKELY(res < eCSSProperty_COUNT)) {
     if (res != eCSSProperty_UNKNOWN && !IsEnabled(res, aEnabled)) {
       res = eCSSProperty_UNKNOWN;
     }
     return res;
   }
   MOZ_ASSERT(eCSSAliasCount != 0,
              "'res' must be an alias at this point so we better have some!");
@@ -543,29 +543,29 @@ nsCSSProps::LookupProperty(const nsACStr
                "aliases must not point to other aliases");
     if (IsEnabled(res) || aEnabled == CSSEnabledState::eIgnoreEnabledState) {
       return res;
     }
   }
   return eCSSProperty_UNKNOWN;
 }
 
-nsCSSPropertyID
+nsCSSProperty
 nsCSSProps::LookupProperty(const nsAString& aProperty, EnabledState aEnabled)
 {
   if (nsLayoutUtils::CSSVariablesEnabled() &&
       IsCustomPropertyName(aProperty)) {
     return eCSSPropertyExtra_variable;
   }
 
   // This is faster than converting and calling
   // LookupProperty(nsACString&).  The table will do its own
   // converting and avoid a PromiseFlatCString() call.
   MOZ_ASSERT(gPropertyTable, "no lookup table, needs addref");
-  nsCSSPropertyID res = nsCSSPropertyID(gPropertyTable->Lookup(aProperty));
+  nsCSSProperty res = nsCSSProperty(gPropertyTable->Lookup(aProperty));
   if (MOZ_LIKELY(res < eCSSProperty_COUNT)) {
     if (res != eCSSProperty_UNKNOWN && !IsEnabled(res, aEnabled)) {
       res = eCSSProperty_UNKNOWN;
     }
     return res;
   }
   MOZ_ASSERT(eCSSAliasCount != 0,
              "'res' must be an alias at this point so we better have some!");
@@ -578,32 +578,32 @@ nsCSSProps::LookupProperty(const nsAStri
                "aliases must not point to other aliases");
     if (IsEnabled(res) || aEnabled == CSSEnabledState::eIgnoreEnabledState) {
       return res;
     }
   }
   return eCSSProperty_UNKNOWN;
 }
 
-nsCSSPropertyID
+nsCSSProperty
 nsCSSProps::LookupPropertyByIDLName(const nsACString& aPropertyIDLName,
                                     EnabledState aEnabled)
 {
-  nsCSSPropertyID res;
+  nsCSSProperty res;
   if (!gPropertyIDLNameTable->Get(aPropertyIDLName, &res)) {
     return eCSSProperty_UNKNOWN;
   }
   MOZ_ASSERT(res < eCSSProperty_COUNT);
   if (!IsEnabled(res, aEnabled)) {
     return eCSSProperty_UNKNOWN;
   }
   return res;
 }
 
-nsCSSPropertyID
+nsCSSProperty
 nsCSSProps::LookupPropertyByIDLName(const nsAString& aPropertyIDLName,
                                     EnabledState aEnabled)
 {
   MOZ_ASSERT(gPropertyIDLNameTable, "no lookup table, needs addref");
   return LookupPropertyByIDLName(NS_ConvertUTF16toUTF8(aPropertyIDLName),
                                  aEnabled);
 }
 
@@ -673,17 +673,17 @@ nsCSSProps::IsPredefinedCounterStyle(con
 {
   MOZ_ASSERT(gPredefinedCounterStyleTable,
              "no lookup table, needs addref");
   return gPredefinedCounterStyleTable->Lookup(aStyle) !=
     nsStaticCaseInsensitiveNameTable::NOT_FOUND;
 }
 
 const nsAFlatCString&
-nsCSSProps::GetStringValue(nsCSSPropertyID aProperty)
+nsCSSProps::GetStringValue(nsCSSProperty aProperty)
 {
   MOZ_ASSERT(gPropertyTable, "no lookup table, needs addref");
   if (gPropertyTable) {
     return gPropertyTable->GetStringValue(int32_t(aProperty));
   } else {
     static nsDependentCString sNullStr("");
     return sNullStr;
   }
@@ -2499,17 +2499,17 @@ nsCSSProps::kKeywordTableTable[eCSSPrope
     kwtable_,
   #define CSS_PROP_LIST_INCLUDE_LOGICAL
   #include "nsCSSPropList.h"
   #undef CSS_PROP_LIST_INCLUDE_LOGICAL
   #undef CSS_PROP
 };
 
 const nsAFlatCString&
-nsCSSProps::LookupPropertyValue(nsCSSPropertyID aProp, int32_t aValue)
+nsCSSProps::LookupPropertyValue(nsCSSProperty aProp, int32_t aValue)
 {
   MOZ_ASSERT(aProp >= 0 && aProp < eCSSProperty_COUNT,
              "property out of range");
 #ifdef DEBUG
   typedef decltype(KTableEntry::mValue) table_value_type;
   NS_ASSERTION(table_value_type(aValue) == aValue, "Value out of range");
 #endif
 
@@ -2583,84 +2583,84 @@ const uint32_t nsCSSProps::kFlagsTable[e
 #include "nsCSSPropList.h"
 #undef CSS_PROP_LIST_INCLUDE_LOGICAL
 #undef CSS_PROP
 #define CSS_PROP_SHORTHAND(name_, id_, method_, flags_, pref_) flags_,
 #include "nsCSSPropList.h"
 #undef CSS_PROP_SHORTHAND
 };
 
-static const nsCSSPropertyID gAllSubpropTable[] = {
+static const nsCSSProperty gAllSubpropTable[] = {
 #define CSS_PROP_LIST_ONLY_COMPONENTS_OF_ALL_SHORTHAND
 #define CSS_PROP_LIST_INCLUDE_LOGICAL
 #define CSS_PROP(name_, id_, method_, flags_, pref_, parsevariant_, kwtable_, \
                  stylestruct_, stylestructoffset_, animtype_)                 \
   eCSSProperty_##id_,
 #include "nsCSSPropList.h"
 #undef CSS_PROP
 #undef CSS_PROP_LIST_INCLUDE_LOGICAL
 #undef CSS_PROP_LIST_ONLY_COMPONENTS_OF_ALL_SHORTHAND
   eCSSProperty_UNKNOWN
 };
 
-static const nsCSSPropertyID gAnimationSubpropTable[] = {
+static const nsCSSProperty gAnimationSubpropTable[] = {
   eCSSProperty_animation_duration,
   eCSSProperty_animation_timing_function,
   eCSSProperty_animation_delay,
   eCSSProperty_animation_direction,
   eCSSProperty_animation_fill_mode,
   eCSSProperty_animation_iteration_count,
   eCSSProperty_animation_play_state,
   // List animation-name last so we serialize it last, in case it has
   // a value that conflicts with one of the other properties.  (See
   // how Declaration::GetValue serializes 'animation'.
   eCSSProperty_animation_name,
   eCSSProperty_UNKNOWN
 };
 
-static const nsCSSPropertyID gBorderRadiusSubpropTable[] = {
+static const nsCSSProperty gBorderRadiusSubpropTable[] = {
   // Code relies on these being in topleft-topright-bottomright-bottomleft
   // order.
   eCSSProperty_border_top_left_radius,
   eCSSProperty_border_top_right_radius,
   eCSSProperty_border_bottom_right_radius,
   eCSSProperty_border_bottom_left_radius,
   eCSSProperty_UNKNOWN
 };
 
-static const nsCSSPropertyID gOutlineRadiusSubpropTable[] = {
+static const nsCSSProperty gOutlineRadiusSubpropTable[] = {
   // Code relies on these being in topleft-topright-bottomright-bottomleft
   // order.
   eCSSProperty__moz_outline_radius_topLeft,
   eCSSProperty__moz_outline_radius_topRight,
   eCSSProperty__moz_outline_radius_bottomRight,
   eCSSProperty__moz_outline_radius_bottomLeft,
   eCSSProperty_UNKNOWN
 };
 
-static const nsCSSPropertyID gBackgroundSubpropTable[] = {
+static const nsCSSProperty gBackgroundSubpropTable[] = {
   eCSSProperty_background_color,
   eCSSProperty_background_image,
   eCSSProperty_background_repeat,
   eCSSProperty_background_attachment,
   eCSSProperty_background_clip,
   eCSSProperty_background_origin,
   eCSSProperty_background_position_x,
   eCSSProperty_background_position_y,
   eCSSProperty_background_size,
   eCSSProperty_UNKNOWN
 };
 
-static const nsCSSPropertyID gBackgroundPositionSubpropTable[] = {
+static const nsCSSProperty gBackgroundPositionSubpropTable[] = {
   eCSSProperty_background_position_x,
   eCSSProperty_background_position_y,
   eCSSProperty_UNKNOWN
 };
 
-static const nsCSSPropertyID gBorderSubpropTable[] = {
+static const nsCSSProperty gBorderSubpropTable[] = {
   eCSSProperty_border_top_width,
   eCSSProperty_border_right_width,
   eCSSProperty_border_bottom_width,
   eCSSProperty_border_left_width,
   eCSSProperty_border_top_style,
   eCSSProperty_border_right_style,
   eCSSProperty_border_bottom_style,
   eCSSProperty_border_left_style,
@@ -2675,120 +2675,120 @@ static const nsCSSPropertyID gBorderSubp
   eCSSProperty_border_image_source,
   eCSSProperty_border_image_slice,
   eCSSProperty_border_image_width,
   eCSSProperty_border_image_outset,
   eCSSProperty_border_image_repeat,
   eCSSProperty_UNKNOWN
 };
 
-static const nsCSSPropertyID gBorderBlockEndSubpropTable[] = {
+static const nsCSSProperty gBorderBlockEndSubpropTable[] = {
   // Declaration.cpp outputs the subproperties in this order.
   // It also depends on the color being third.
   eCSSProperty_border_block_end_width,
   eCSSProperty_border_block_end_style,
   eCSSProperty_border_block_end_color,
   eCSSProperty_UNKNOWN
 };
 
-static const nsCSSPropertyID gBorderBlockStartSubpropTable[] = {
+static const nsCSSProperty gBorderBlockStartSubpropTable[] = {
   // Declaration.cpp outputs the subproperties in this order.
   // It also depends on the color being third.
   eCSSProperty_border_block_start_width,
   eCSSProperty_border_block_start_style,
   eCSSProperty_border_block_start_color,
   eCSSProperty_UNKNOWN
 };
 
-static const nsCSSPropertyID gBorderBottomSubpropTable[] = {
+static const nsCSSProperty gBorderBottomSubpropTable[] = {
   // Declaration.cpp outputs the subproperties in this order.
   // It also depends on the color being third.
   eCSSProperty_border_bottom_width,
   eCSSProperty_border_bottom_style,
   eCSSProperty_border_bottom_color,
   eCSSProperty_UNKNOWN
 };
 
 static_assert(NS_SIDE_TOP == 0 && NS_SIDE_RIGHT == 1 &&
               NS_SIDE_BOTTOM == 2 && NS_SIDE_LEFT == 3,
               "box side constants not top/right/bottom/left == 0/1/2/3");
-static const nsCSSPropertyID gBorderColorSubpropTable[] = {
+static const nsCSSProperty gBorderColorSubpropTable[] = {
   // Code relies on these being in top-right-bottom-left order.
   // Code relies on these matching the NS_SIDE_* constants.
   eCSSProperty_border_top_color,
   eCSSProperty_border_right_color,
   eCSSProperty_border_bottom_color,
   eCSSProperty_border_left_color,
   eCSSProperty_UNKNOWN
 };
 
-static const nsCSSPropertyID gBorderInlineEndSubpropTable[] = {
+static const nsCSSProperty gBorderInlineEndSubpropTable[] = {
   // Declaration.cpp output the subproperties in this order.
   // It also depends on the color being third.
   eCSSProperty_border_inline_end_width,
   eCSSProperty_border_inline_end_style,
   eCSSProperty_border_inline_end_color,
   eCSSProperty_UNKNOWN
 };
 
-static const nsCSSPropertyID gBorderLeftSubpropTable[] = {
+static const nsCSSProperty gBorderLeftSubpropTable[] = {
   // Declaration.cpp outputs the subproperties in this order.
   // It also depends on the color being third.
   eCSSProperty_border_left_width,
   eCSSProperty_border_left_style,
   eCSSProperty_border_left_color,
   eCSSProperty_UNKNOWN
 };
 
-static const nsCSSPropertyID gBorderRightSubpropTable[] = {
+static const nsCSSProperty gBorderRightSubpropTable[] = {
   // Declaration.cpp outputs the subproperties in this order.
   // It also depends on the color being third.
   eCSSProperty_border_right_width,
   eCSSProperty_border_right_style,
   eCSSProperty_border_right_color,
   eCSSProperty_UNKNOWN
 };
 
-static const nsCSSPropertyID gBorderInlineStartSubpropTable[] = {
+static const nsCSSProperty gBorderInlineStartSubpropTable[] = {
   // Declaration.cpp outputs the subproperties in this order.
   // It also depends on the color being third.
   eCSSProperty_border_inline_start_width,
   eCSSProperty_border_inline_start_style,
   eCSSProperty_border_inline_start_color,
   eCSSProperty_UNKNOWN
 };
 
-static const nsCSSPropertyID gBorderStyleSubpropTable[] = {
+static const nsCSSProperty gBorderStyleSubpropTable[] = {
   // Code relies on these being in top-right-bottom-left order.
   eCSSProperty_border_top_style,
   eCSSProperty_border_right_style,
   eCSSProperty_border_bottom_style,
   eCSSProperty_border_left_style,
   eCSSProperty_UNKNOWN
 };
 
-static const nsCSSPropertyID gBorderTopSubpropTable[] = {
+static const nsCSSProperty gBorderTopSubpropTable[] = {
   // Declaration.cpp outputs the subproperties in this order.
   // It also depends on the color being third.
   eCSSProperty_border_top_width,
   eCSSProperty_border_top_style,
   eCSSProperty_border_top_color,
   eCSSProperty_UNKNOWN
 };
 
-static const nsCSSPropertyID gBorderWidthSubpropTable[] = {
+static const nsCSSProperty gBorderWidthSubpropTable[] = {
   // Code relies on these being in top-right-bottom-left order.
   eCSSProperty_border_top_width,
   eCSSProperty_border_right_width,
   eCSSProperty_border_bottom_width,
   eCSSProperty_border_left_width,
   eCSSProperty_UNKNOWN
 };
 
-static const nsCSSPropertyID gFontSubpropTable[] = {
+static const nsCSSProperty gFontSubpropTable[] = {
   eCSSProperty_font_family,
   eCSSProperty_font_style,
   eCSSProperty_font_weight,
   eCSSProperty_font_size,
   eCSSProperty_line_height,
   eCSSProperty_font_size_adjust,
   eCSSProperty_font_stretch,
   eCSSProperty__x_system_font,
@@ -2800,286 +2800,286 @@ static const nsCSSPropertyID gFontSubpro
   eCSSProperty_font_variant_caps,
   eCSSProperty_font_variant_east_asian,
   eCSSProperty_font_variant_ligatures,
   eCSSProperty_font_variant_numeric,
   eCSSProperty_font_variant_position,
   eCSSProperty_UNKNOWN
 };
 
-static const nsCSSPropertyID gFontVariantSubpropTable[] = {
+static const nsCSSProperty gFontVariantSubpropTable[] = {
   eCSSProperty_font_variant_alternates,
   eCSSProperty_font_variant_caps,
   eCSSProperty_font_variant_east_asian,
   eCSSProperty_font_variant_ligatures,
   eCSSProperty_font_variant_numeric,
   eCSSProperty_font_variant_position,
   eCSSProperty_UNKNOWN
 };
 
-static const nsCSSPropertyID gListStyleSubpropTable[] = {
+static const nsCSSProperty gListStyleSubpropTable[] = {
   eCSSProperty_list_style_type,
   eCSSProperty_list_style_image,
   eCSSProperty_list_style_position,
   eCSSProperty_UNKNOWN
 };
 
-static const nsCSSPropertyID gMarginSubpropTable[] = {
+static const nsCSSProperty gMarginSubpropTable[] = {
   // Code relies on these being in top-right-bottom-left order.
   eCSSProperty_margin_top,
   eCSSProperty_margin_right,
   eCSSProperty_margin_bottom,
   eCSSProperty_margin_left,
   eCSSProperty_UNKNOWN
 };
 
 
-static const nsCSSPropertyID gOutlineSubpropTable[] = {
+static const nsCSSProperty gOutlineSubpropTable[] = {
   // nsCSSDeclaration.cpp outputs the subproperties in this order.
   // It also depends on the color being third.
   eCSSProperty_outline_width,
   eCSSProperty_outline_style,
   eCSSProperty_outline_color,
   eCSSProperty_UNKNOWN
 };
 
-static const nsCSSPropertyID gColumnsSubpropTable[] = {
+static const nsCSSProperty gColumnsSubpropTable[] = {
   eCSSProperty__moz_column_count,
   eCSSProperty__moz_column_width,
   eCSSProperty_UNKNOWN
 };
 
-static const nsCSSPropertyID gColumnRuleSubpropTable[] = {
+static const nsCSSProperty gColumnRuleSubpropTable[] = {
   // nsCSSDeclaration.cpp outputs the subproperties in this order.
   // It also depends on the color being third.
   eCSSProperty__moz_column_rule_width,
   eCSSProperty__moz_column_rule_style,
   eCSSProperty__moz_column_rule_color,
   eCSSProperty_UNKNOWN
 };
 
-static const nsCSSPropertyID gFlexSubpropTable[] = {
+static const nsCSSProperty gFlexSubpropTable[] = {
   eCSSProperty_flex_grow,
   eCSSProperty_flex_shrink,
   eCSSProperty_flex_basis,
   eCSSProperty_UNKNOWN
 };
 
-static const nsCSSPropertyID gFlexFlowSubpropTable[] = {
+static const nsCSSProperty gFlexFlowSubpropTable[] = {
   eCSSProperty_flex_direction,
   eCSSProperty_flex_wrap,
   eCSSProperty_UNKNOWN
 };
 
-static const nsCSSPropertyID gGridTemplateSubpropTable[] = {
+static const nsCSSProperty gGridTemplateSubpropTable[] = {
   eCSSProperty_grid_template_areas,
   eCSSProperty_grid_template_rows, 
   eCSSProperty_grid_template_columns,
   eCSSProperty_UNKNOWN
 };
 
-static const nsCSSPropertyID gGridSubpropTable[] = {
+static const nsCSSProperty gGridSubpropTable[] = {
   eCSSProperty_grid_template_areas,
   eCSSProperty_grid_template_rows,
   eCSSProperty_grid_template_columns,
   eCSSProperty_grid_auto_flow,
   eCSSProperty_grid_auto_rows,
   eCSSProperty_grid_auto_columns,
   eCSSProperty_grid_row_gap, // can only be reset, not get/set
   eCSSProperty_grid_column_gap, // can only be reset, not get/set
   eCSSProperty_UNKNOWN
 };
 
-static const nsCSSPropertyID gGridColumnSubpropTable[] = {
+static const nsCSSProperty gGridColumnSubpropTable[] = {
   eCSSProperty_grid_column_start,
   eCSSProperty_grid_column_end,
   eCSSProperty_UNKNOWN
 };
 
-static const nsCSSPropertyID gGridRowSubpropTable[] = {
+static const nsCSSProperty gGridRowSubpropTable[] = {
   eCSSProperty_grid_row_start,
   eCSSProperty_grid_row_end,
   eCSSProperty_UNKNOWN
 };
 
-static const nsCSSPropertyID gGridAreaSubpropTable[] = {
+static const nsCSSProperty gGridAreaSubpropTable[] = {
   eCSSProperty_grid_row_start,
   eCSSProperty_grid_column_start,
   eCSSProperty_grid_row_end,
   eCSSProperty_grid_column_end,
   eCSSProperty_UNKNOWN
 };
 
-static const nsCSSPropertyID gGridGapSubpropTable[] = {
+static const nsCSSProperty gGridGapSubpropTable[] = {
   eCSSProperty_grid_row_gap,
   eCSSProperty_grid_column_gap,
   eCSSProperty_UNKNOWN
 };
 
-static const nsCSSPropertyID gOverflowSubpropTable[] = {
+static const nsCSSProperty gOverflowSubpropTable[] = {
   eCSSProperty_overflow_x,
   eCSSProperty_overflow_y,
   eCSSProperty_UNKNOWN
 };
 
-static const nsCSSPropertyID gPaddingSubpropTable[] = {
+static const nsCSSProperty gPaddingSubpropTable[] = {
   // Code relies on these being in top-right-bottom-left order.
   eCSSProperty_padding_top,
   eCSSProperty_padding_right,
   eCSSProperty_padding_bottom,
   eCSSProperty_padding_left,
   eCSSProperty_UNKNOWN
 };
 
-static const nsCSSPropertyID gTextDecorationSubpropTable[] = {
+static const nsCSSProperty gTextDecorationSubpropTable[] = {
   eCSSProperty_text_decoration_color,
   eCSSProperty_text_decoration_line,
   eCSSProperty_text_decoration_style,
   eCSSProperty_UNKNOWN
 };
 
-static const nsCSSPropertyID gTextEmphasisSubpropTable[] = {
+static const nsCSSProperty gTextEmphasisSubpropTable[] = {
   eCSSProperty_text_emphasis_style,
   eCSSProperty_text_emphasis_color,
   eCSSProperty_UNKNOWN
 };
 
-static const nsCSSPropertyID gWebkitTextStrokeSubpropTable[] = {
+static const nsCSSProperty gWebkitTextStrokeSubpropTable[] = {
   eCSSProperty__webkit_text_stroke_width,
   eCSSProperty__webkit_text_stroke_color,
   eCSSProperty_UNKNOWN
 };
 
-static const nsCSSPropertyID gTransitionSubpropTable[] = {
+static const nsCSSProperty gTransitionSubpropTable[] = {
   eCSSProperty_transition_property,
   eCSSProperty_transition_duration,
   eCSSProperty_transition_timing_function,
   eCSSProperty_transition_delay,
   eCSSProperty_UNKNOWN
 };
 
-static const nsCSSPropertyID gBorderImageSubpropTable[] = {
+static const nsCSSProperty gBorderImageSubpropTable[] = {
   eCSSProperty_border_image_source,
   eCSSProperty_border_image_slice,
   eCSSProperty_border_image_width,
   eCSSProperty_border_image_outset,
   eCSSProperty_border_image_repeat,
   eCSSProperty_UNKNOWN
 };
 
-static const nsCSSPropertyID gMarkerSubpropTable[] = {
+static const nsCSSProperty gMarkerSubpropTable[] = {
   eCSSProperty_marker_start,
   eCSSProperty_marker_mid,
   eCSSProperty_marker_end,
   eCSSProperty_UNKNOWN
 };
 
 // Subproperty tables for shorthands that are just aliases with
 // different parsing rules.
-static const nsCSSPropertyID gMozTransformSubpropTable[] = {
+static const nsCSSProperty gMozTransformSubpropTable[] = {
   eCSSProperty_transform,
   eCSSProperty_UNKNOWN
 };
 
-static const nsCSSPropertyID gScrollSnapTypeSubpropTable[] = {
+static const nsCSSProperty gScrollSnapTypeSubpropTable[] = {
   eCSSProperty_scroll_snap_type_x,
   eCSSProperty_scroll_snap_type_y,
   eCSSProperty_UNKNOWN
 };
 #ifdef MOZ_ENABLE_MASK_AS_SHORTHAND
-static const nsCSSPropertyID gMaskSubpropTable[] = {
+static const nsCSSProperty gMaskSubpropTable[] = {
   eCSSProperty_mask_image,
   eCSSProperty_mask_repeat,
   eCSSProperty_mask_position_x,
   eCSSProperty_mask_position_y,
   eCSSProperty_mask_clip,
   eCSSProperty_mask_origin,
   eCSSProperty_mask_size,
   eCSSProperty_mask_composite,
   eCSSProperty_mask_mode,
   eCSSProperty_UNKNOWN
 };
-static const nsCSSPropertyID gMaskPositionSubpropTable[] = {
+static const nsCSSProperty gMaskPositionSubpropTable[] = {
   eCSSProperty_mask_position_x,
   eCSSProperty_mask_position_y,
   eCSSProperty_UNKNOWN
 };
 #endif
 // FIXME: mask-border tables should be added when we implement
 // mask-border properties.
 
-const nsCSSPropertyID *const
+const nsCSSProperty *const
 nsCSSProps::kSubpropertyTable[eCSSProperty_COUNT - eCSSProperty_COUNT_no_shorthands] = {
 #define CSS_PROP_PUBLIC_OR_PRIVATE(publicname_, privatename_) privatename_
 // Need an extra level of macro nesting to force expansion of method_
 // params before they get pasted.
 #define NSCSSPROPS_INNER_MACRO(method_) g##method_##SubpropTable,
 #define CSS_PROP_SHORTHAND(name_, id_, method_, flags_, pref_) \
   NSCSSPROPS_INNER_MACRO(method_)
 #include "nsCSSPropList.h"
 #undef CSS_PROP_SHORTHAND
 #undef NSCSSPROPS_INNER_MACRO
 #undef CSS_PROP_PUBLIC_OR_PRIVATE
 };
 
 
-static const nsCSSPropertyID gOffsetLogicalGroupTable[] = {
+static const nsCSSProperty gOffsetLogicalGroupTable[] = {
   eCSSProperty_top,
   eCSSProperty_right,
   eCSSProperty_bottom,
   eCSSProperty_left,
   eCSSProperty_UNKNOWN
 };
 
-static const nsCSSPropertyID gMaxSizeLogicalGroupTable[] = {
+static const nsCSSProperty gMaxSizeLogicalGroupTable[] = {
   eCSSProperty_max_height,
   eCSSProperty_max_width,
   eCSSProperty_UNKNOWN
 };
 
-static const nsCSSPropertyID gMinSizeLogicalGroupTable[] = {
+static const nsCSSProperty gMinSizeLogicalGroupTable[] = {
   eCSSProperty_min_height,
   eCSSProperty_min_width,
   eCSSProperty_UNKNOWN
 };
 
-static const nsCSSPropertyID gSizeLogicalGroupTable[] = {
+static const nsCSSProperty gSizeLogicalGroupTable[] = {
   eCSSProperty_height,
   eCSSProperty_width,
   eCSSProperty_UNKNOWN
 };
 
-const nsCSSPropertyID* const
+const nsCSSProperty* const
 nsCSSProps::kLogicalGroupTable[eCSSPropertyLogicalGroup_COUNT] = {
 #define CSS_PROP_LOGICAL_GROUP_SHORTHAND(id_) g##id_##SubpropTable,
 #define CSS_PROP_LOGICAL_GROUP_AXIS(name_) g##name_##LogicalGroupTable,
 #define CSS_PROP_LOGICAL_GROUP_BOX(name_) g##name_##LogicalGroupTable,
 #include "nsCSSPropLogicalGroupList.h"
 #undef CSS_PROP_LOGICAL_GROUP_BOX
 #undef CSS_PROP_LOGICAL_GROUP_AXIS
 #undef CSS_PROP_LOGICAL_GROUP_SHORTHAND
 };
 
 // Mapping of logical longhand properties to their logical group (which
 // represents the physical longhands the logical properties an correspond
 // to).  The format is pairs of values, where the first is the logical
-// longhand property (an nsCSSPropertyID) and the second is the logical group
+// longhand property (an nsCSSProperty) and the second is the logical group
 // (an nsCSSPropertyLogicalGroup), stored in a flat array (like KTableEntry
 // arrays).
 static const int gLogicalGroupMappingTable[] = {
 #define CSS_PROP_LOGICAL(name_, id_, method_, flags_, pref_, parsevariant_, \
                          kwtable_, group_, stylestruct_,                    \
                          stylestructoffset_, animtype_)                     \
   eCSSProperty_##id_, eCSSPropertyLogicalGroup_##group_,
 #include "nsCSSPropList.h"
 #undef CSS_PROP_LOGICAL
 };
 
-/* static */ const nsCSSPropertyID*
-nsCSSProps::LogicalGroup(nsCSSPropertyID aProperty)
+/* static */ const nsCSSProperty*
+nsCSSProps::LogicalGroup(nsCSSProperty aProperty)
 {
   MOZ_ASSERT(0 <= aProperty && aProperty < eCSSProperty_COUNT_no_shorthands,
              "out of range");
   MOZ_ASSERT(nsCSSProps::PropHasFlags(aProperty, CSS_PROPERTY_LOGICAL),
              "aProperty must be a logical longhand property");
 
   for (size_t i = 0; i < ArrayLength(gLogicalGroupMappingTable); i += 2) {
     if (gLogicalGroupMappingTable[i] == aProperty) {
--- a/layout/style/nsCSSProps.h
+++ b/layout/style/nsCSSProps.h
@@ -9,17 +9,17 @@
  */
 
 #ifndef nsCSSProps_h___
 #define nsCSSProps_h___
 
 #include <limits>
 #include <type_traits>
 #include "nsString.h"
-#include "nsCSSPropertyID.h"
+#include "nsCSSProperty.h"
 #include "nsStyleStructFwd.h"
 #include "nsCSSKeywords.h"
 #include "mozilla/CSSEnabledState.h"
 #include "mozilla/UseCounter.h"
 
 // Length of the "--" prefix on custom names (such as custom property names,
 // and, in the future, custom media query names).
 #define CSS_CUSTOM_NAME_PREFIX_LENGTH 2
@@ -158,17 +158,17 @@
 
 // This property allows calc() between lengths and percentages and
 // stores such calc() expressions in its style structs (typically in an
 // nsStyleCoord, although this is not the case for 'background-position'
 // and 'background-size').
 #define CSS_PROPERTY_STORES_CALC                  (1<<8)
 
 // Define what mechanism the CSS parser uses for parsing the property.
-// See CSSParserImpl::ParseProperty(nsCSSPropertyID).  Don't use 0 so that
+// See CSSParserImpl::ParseProperty(nsCSSProperty).  Don't use 0 so that
 // we can verify that every property sets one of the values.
 //
 // CSS_PROPERTY_PARSE_FUNCTION must be used for shorthand properties,
 // since it's the only mechanism that allows appending values for
 // separate properties.  Longhand properties that require custom parsing
 // functions should prefer using CSS_PROPERTY_PARSE_VALUE (or
 // CSS_PROPERTY_PARSE_VALUE_LIST) and
 // CSS_PROPERTY_VALUE_PARSER_FUNCTION, though a number of existing
@@ -373,66 +373,66 @@ public:
     nsCSSKeyword mKeyword;
     int16_t mValue;
   };
 
   static void AddRefTable(void);
   static void ReleaseTable(void);
 
   // Looks up the property with name aProperty and returns its corresponding
-  // nsCSSPropertyID value.  If aProperty is the name of a custom property,
+  // nsCSSProperty value.  If aProperty is the name of a custom property,
   // then eCSSPropertyExtra_variable will be returned.
-  static nsCSSPropertyID LookupProperty(const nsAString& aProperty,
+  static nsCSSProperty LookupProperty(const nsAString& aProperty,
                                       EnabledState aEnabled);
-  static nsCSSPropertyID LookupProperty(const nsACString& aProperty,
+  static nsCSSProperty LookupProperty(const nsACString& aProperty,
                                       EnabledState aEnabled);
   // As above, but looked up using a property's IDL name.
   // eCSSPropertyExtra_variable won't be returned from these methods.
-  static nsCSSPropertyID LookupPropertyByIDLName(
+  static nsCSSProperty LookupPropertyByIDLName(
       const nsAString& aPropertyIDLName,
       EnabledState aEnabled);
-  static nsCSSPropertyID LookupPropertyByIDLName(
+  static nsCSSProperty LookupPropertyByIDLName(
       const nsACString& aPropertyIDLName,
       EnabledState aEnabled);
 
   // Returns whether aProperty is a custom property name, i.e. begins with
   // "--".  This assumes that the CSS Variables pref has been enabled.
   static bool IsCustomPropertyName(const nsAString& aProperty);
   static bool IsCustomPropertyName(const nsACString& aProperty);
 
-  static inline bool IsShorthand(nsCSSPropertyID aProperty) {
+  static inline bool IsShorthand(nsCSSProperty aProperty) {
     MOZ_ASSERT(0 <= aProperty && aProperty < eCSSProperty_COUNT,
                "out of range");
     return (aProperty >= eCSSProperty_COUNT_no_shorthands);
   }
 
   // Must be given a longhand property.
-  static bool IsInherited(nsCSSPropertyID aProperty);
+  static bool IsInherited(nsCSSProperty aProperty);
 
   // Same but for @font-face descriptors
   static nsCSSFontDesc LookupFontDesc(const nsAString& aProperty);
   static nsCSSFontDesc LookupFontDesc(const nsACString& aProperty);
 
   // For @counter-style descriptors
   static nsCSSCounterDesc LookupCounterDesc(const nsAString& aProperty);
   static nsCSSCounterDesc LookupCounterDesc(const nsACString& aProperty);
 
   // For predefined counter styles which need to be lower-cased during parse
   static bool IsPredefinedCounterStyle(const nsAString& aStyle);
   static bool IsPredefinedCounterStyle(const nsACString& aStyle);
 
   // Given a property enum, get the string value
-  static const nsAFlatCString& GetStringValue(nsCSSPropertyID aProperty);
+  static const nsAFlatCString& GetStringValue(nsCSSProperty aProperty);
   static const nsAFlatCString& GetStringValue(nsCSSFontDesc aFontDesc);
   static const nsAFlatCString& GetStringValue(nsCSSCounterDesc aCounterDesc);
 
   // Given a CSS Property and a Property Enum Value
   // Return back a const nsString& representation of the
   // value. Return back nullstr if no value is found
-  static const nsAFlatCString& LookupPropertyValue(nsCSSPropertyID aProperty, int32_t aValue);
+  static const nsAFlatCString& LookupPropertyValue(nsCSSProperty aProperty, int32_t aValue);
 
   // Get a color name for a predefined color value like buttonhighlight or activeborder
   // Sets the aStr param to the name of the propertyID
   static bool GetColorName(int32_t aPropID, nsCString &aStr);
 
   // Returns the index of |aKeyword| in |aTable|, if it exists there;
   // otherwise, returns -1.
   // NOTE: Generally, clients should call FindKeyword() instead of this method.
@@ -474,87 +474,87 @@ public:
   static const nsStyleAnimType kAnimTypeTable[eCSSProperty_COUNT_no_shorthands];
   static const ptrdiff_t
     kStyleStructOffsetTable[eCSSProperty_COUNT_no_shorthands];
 
 private:
   static const uint32_t        kFlagsTable[eCSSProperty_COUNT];
 
 public:
-  static inline bool PropHasFlags(nsCSSPropertyID aProperty, uint32_t aFlags)
+  static inline bool PropHasFlags(nsCSSProperty aProperty, uint32_t aFlags)
   {
     MOZ_ASSERT(0 <= aProperty && aProperty < eCSSProperty_COUNT,
                "out of range");
     MOZ_ASSERT(!(aFlags & CSS_PROPERTY_PARSE_PROPERTY_MASK),
                "The CSS_PROPERTY_PARSE_* values are not bitflags; don't pass "
                "them to PropHasFlags.  You probably want PropertyParseType "
                "instead.");
     return (nsCSSProps::kFlagsTable[aProperty] & aFlags) == aFlags;
   }
 
-  static inline uint32_t PropertyParseType(nsCSSPropertyID aProperty)
+  static inline uint32_t PropertyParseType(nsCSSProperty aProperty)
   {
     MOZ_ASSERT(0 <= aProperty && aProperty < eCSSProperty_COUNT,
                "out of range");
     return nsCSSProps::kFlagsTable[aProperty] &
            CSS_PROPERTY_PARSE_PROPERTY_MASK;
   }
 
-  static inline uint32_t ValueRestrictions(nsCSSPropertyID aProperty)
+  static inline uint32_t ValueRestrictions(nsCSSProperty aProperty)
   {
     MOZ_ASSERT(0 <= aProperty && aProperty < eCSSProperty_COUNT,
                "out of range");
     return nsCSSProps::kFlagsTable[aProperty] &
            CSS_PROPERTY_VALUE_RESTRICTION_MASK;
   }
 
 private:
   // Lives in nsCSSParser.cpp for the macros it depends on.
   static const uint32_t kParserVariantTable[eCSSProperty_COUNT_no_shorthands];
 
 public:
-  static inline uint32_t ParserVariant(nsCSSPropertyID aProperty) {
+  static inline uint32_t ParserVariant(nsCSSProperty aProperty) {
     MOZ_ASSERT(0 <= aProperty && aProperty < eCSSProperty_COUNT_no_shorthands,
                "out of range");
     return nsCSSProps::kParserVariantTable[aProperty];
   }
 
 private:
   // A table for shorthand properties.  The appropriate index is the
   // property ID minus eCSSProperty_COUNT_no_shorthands.
-  static const nsCSSPropertyID *const
+  static const nsCSSProperty *const
     kSubpropertyTable[eCSSProperty_COUNT - eCSSProperty_COUNT_no_shorthands];
 
 public:
   static inline
-  const nsCSSPropertyID * SubpropertyEntryFor(nsCSSPropertyID aProperty) {
+  const nsCSSProperty * SubpropertyEntryFor(nsCSSProperty aProperty) {
     MOZ_ASSERT(eCSSProperty_COUNT_no_shorthands <= aProperty &&
                aProperty < eCSSProperty_COUNT,
                "out of range");
     return nsCSSProps::kSubpropertyTable[aProperty -
                                          eCSSProperty_COUNT_no_shorthands];
   }
 
   // Returns an eCSSProperty_UNKNOWN-terminated array of the shorthand
   // properties containing |aProperty|, sorted from those that contain
   // the most properties to those that contain the least.
-  static const nsCSSPropertyID * ShorthandsContaining(nsCSSPropertyID aProperty) {
+  static const nsCSSProperty * ShorthandsContaining(nsCSSProperty aProperty) {
     MOZ_ASSERT(gShorthandsContainingPool, "uninitialized");
     MOZ_ASSERT(0 <= aProperty && aProperty < eCSSProperty_COUNT_no_shorthands,
                "out of range");
     return gShorthandsContainingTable[aProperty];
   }
 private:
   // gShorthandsContainingTable is an array of the return values for
-  // ShorthandsContaining (arrays of nsCSSPropertyID terminated by
+  // ShorthandsContaining (arrays of nsCSSProperty terminated by
   // eCSSProperty_UNKNOWN) pointing into memory in
   // gShorthandsContainingPool (which contains all of those arrays in a
   // single allocation, and is the one pointer that should be |free|d).
-  static nsCSSPropertyID *gShorthandsContainingTable[eCSSProperty_COUNT_no_shorthands];
-  static nsCSSPropertyID* gShorthandsContainingPool;
+  static nsCSSProperty *gShorthandsContainingTable[eCSSProperty_COUNT_no_shorthands];
+  static nsCSSProperty* gShorthandsContainingPool;
   static bool BuildShorthandsContainingTable();
 
 private:
   static const size_t gPropertyCountInStruct[nsStyleStructID_Length];
   static const size_t gPropertyIndexInStruct[eCSSProperty_COUNT_no_shorthands];
 public:
   /**
    * Return the number of properties that must be cascaded when
@@ -564,26 +564,26 @@ public:
     MOZ_ASSERT(0 <= aSID && aSID < nsStyleStructID_Length,
                "out of range");
     return gPropertyCountInStruct[aSID];
   }
   /**
    * Return an index for aProperty that is unique within its SID and in
    * the range 0 <= index < PropertyCountInStruct(aSID).
    */
-  static size_t PropertyIndexInStruct(nsCSSPropertyID aProperty) {
+  static size_t PropertyIndexInStruct(nsCSSProperty aProperty) {
     MOZ_ASSERT(0 <= aProperty && aProperty < eCSSProperty_COUNT_no_shorthands,
                "out of range");
     return gPropertyIndexInStruct[aProperty];
   }
 
 private:
   // A table for logical property groups.  Indexes are
   // nsCSSPropertyLogicalGroup values.
-  static const nsCSSPropertyID* const
+  static const nsCSSProperty* const
     kLogicalGroupTable[eCSSPropertyLogicalGroup_COUNT];
 
 public:
   /**
    * Returns an array of longhand physical properties which can be set by
    * the argument, which must be a logical longhand property.  The returned
    * array is terminated by an eCSSProperty_UNKNOWN value.  For example,
    * given eCSSProperty_margin_block_start, returns an array of the four
@@ -595,17 +595,17 @@ public:
    * flag, the returned array will have two values preceding the sentinel;
    * otherwise it will have four.
    *
    * (Note that the running time of this function is proportional to the
    * number of logical longhand properties that exist.  If we start
    * getting too many of these properties, we should make kLogicalGroupTable
    * be a simple array of eCSSProperty_COUNT length.)
    */
-  static const nsCSSPropertyID* LogicalGroup(nsCSSPropertyID aProperty);
+  static const nsCSSProperty* LogicalGroup(nsCSSProperty aProperty);
 
 private:
   static bool gPropertyEnabled[eCSSProperty_COUNT_with_aliases];
 
 private:
   // Defined in the generated nsCSSPropsGenerated.inc.
   static const char* const kIDLNameTable[eCSSProperty_COUNT];
 
@@ -615,58 +615,58 @@ public:
    * longhand, logical or shorthand property.  The IDL name is the property
    * name with any hyphen-lowercase character pairs replaced by an
    * uppercase character:
    * https://drafts.csswg.org/cssom/#css-property-to-idl-attribute
    *
    * As a special case, the string "cssFloat" is returned for the float
    * property.  nullptr is returned for internal properties.
    */
-  static const char* PropertyIDLName(nsCSSPropertyID aProperty)
+  static const char* PropertyIDLName(nsCSSProperty aProperty)
   {
     MOZ_ASSERT(0 <= aProperty && aProperty < eCSSProperty_COUNT,
                "out of range");
     return kIDLNameTable[aProperty];
   }
 
 private:
   static const int32_t kIDLNameSortPositionTable[eCSSProperty_COUNT];
 
 public:
   /**
    * Returns the position of the specified property in a list of all
    * properties sorted by their IDL name.
    */
-  static int32_t PropertyIDLNameSortPosition(nsCSSPropertyID aProperty)
+  static int32_t PropertyIDLNameSortPosition(nsCSSProperty aProperty)
   {
     MOZ_ASSERT(0 <= aProperty && aProperty < eCSSProperty_COUNT,
                "out of range");
     return kIDLNameSortPositionTable[aProperty];
   }
 
-  static bool IsEnabled(nsCSSPropertyID aProperty) {
+  static bool IsEnabled(nsCSSProperty aProperty) {
     MOZ_ASSERT(0 <= aProperty && aProperty < eCSSProperty_COUNT_with_aliases,
                "out of range");
     return gPropertyEnabled[aProperty];
   }
 
   // A table for the use counter associated with each CSS property.  If a
   // property does not have a use counter defined in UseCounters.conf, then
   // its associated entry is |eUseCounter_UNKNOWN|.
   static const mozilla::UseCounter gPropertyUseCounter[eCSSProperty_COUNT_no_shorthands];
 
 public:
 
-  static mozilla::UseCounter UseCounterFor(nsCSSPropertyID aProperty) {
+  static mozilla::UseCounter UseCounterFor(nsCSSProperty aProperty) {
     MOZ_ASSERT(0 <= aProperty && aProperty < eCSSProperty_COUNT_no_shorthands,
                "out of range");
     return gPropertyUseCounter[aProperty];
   }
 
-  static bool IsEnabled(nsCSSPropertyID aProperty, EnabledState aEnabled)
+  static bool IsEnabled(nsCSSProperty aProperty, EnabledState aEnabled)
   {
     if (IsEnabled(aProperty)) {
       return true;
     }
     if (aEnabled == EnabledState::eIgnoreEnabledState) {
       return true;
     }
     if ((aEnabled & EnabledState::eInUASheets) &&
@@ -679,23 +679,23 @@ public:
     {
       return true;
     }
     return false;
   }
 
 public:
 
-// Storing the enabledstate_ value in an nsCSSPropertyID variable is a small hack
+// Storing the enabledstate_ value in an nsCSSProperty variable is a small hack
 // to avoid needing a separate variable declaration for its real type
 // (CSSEnabledState), which would then require using a block and
 // therefore a pair of macros by consumers for the start and end of the loop.
 #define CSSPROPS_FOR_SHORTHAND_SUBPROPERTIES(it_, prop_, enabledstate_)   \
-  for (const nsCSSPropertyID *it_ = nsCSSProps::SubpropertyEntryFor(prop_), \
-                            es_ = (nsCSSPropertyID)((enabledstate_) |       \
+  for (const nsCSSProperty *it_ = nsCSSProps::SubpropertyEntryFor(prop_), \
+                            es_ = (nsCSSProperty)((enabledstate_) |       \
                                                   CSSEnabledState(0));    \
        *it_ != eCSSProperty_UNKNOWN; ++it_)                               \
     if (nsCSSProps::IsEnabled(*it_, (mozilla::CSSEnabledState) es_))
 
   // Keyword/Enum value tables
   static const KTableEntry kAnimationDirectionKTable[];
   static const KTableEntry kAnimationFillModeKTable[];
   static const KTableEntry kAnimationIterationCountKTable[];
--- a/layout/style/nsCSSRules.cpp
+++ b/layout/style/nsCSSRules.cpp
@@ -1459,26 +1459,26 @@ nsCSSFontFaceStyleDecl::IndexedGetter(ui
 NS_IMETHODIMP
 nsCSSFontFaceStyleDecl::GetParentRule(nsIDOMCSSRule** aParentRule)
 {
   NS_IF_ADDREF(*aParentRule = ContainingRule()->GetDOMRule());
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsCSSFontFaceStyleDecl::GetPropertyValue(const nsCSSPropertyID aPropID,
+nsCSSFontFaceStyleDecl::GetPropertyValue(const nsCSSProperty aPropID,
                                          nsAString& aValue)
 {
   return
     GetPropertyValue(NS_ConvertUTF8toUTF16(nsCSSProps::GetStringValue(aPropID)),
                      aValue);
 }
 
 NS_IMETHODIMP
-nsCSSFontFaceStyleDecl::SetPropertyValue(const nsCSSPropertyID aPropID,
+nsCSSFontFaceStyleDecl::SetPropertyValue(const nsCSSProperty aPropID,
                                          const nsAString& aValue)
 {
   return SetProperty(NS_ConvertUTF8toUTF16(nsCSSProps::GetStringValue(aPropID)),
                      aValue, EmptyString());
 }
 
 nsINode*
 nsCSSFontFaceStyleDecl::GetParentObject()
--- a/layout/style/nsCSSRules.h
+++ b/layout/style/nsCSSRules.h
@@ -14,17 +14,17 @@
 #include "gfxFontFeatures.h"
 #include "mozilla/Attributes.h"
 #include "mozilla/MemoryReporting.h"
 #include "mozilla/Move.h"
 #include "mozilla/SheetType.h"
 #include "mozilla/css/GroupRule.h"
 #include "mozilla/dom/FontFace.h"
 #include "nsAutoPtr.h"
-#include "nsCSSPropertyID.h"
+#include "nsCSSProperty.h"
 #include "nsCSSValue.h"
 #include "nsDOMCSSDeclaration.h"
 #include "nsIDOMCSSConditionRule.h"
 #include "nsIDOMCSSCounterStyleRule.h"
 #include "nsIDOMCSSFontFaceRule.h"
 #include "nsIDOMCSSFontFeatureValuesRule.h"
 #include "nsIDOMCSSGroupingRule.h"
 #include "nsIDOMCSSMediaRule.h"
--- a/layout/style/nsCSSValue.cpp
+++ b/layout/style/nsCSSValue.cpp
@@ -841,17 +841,17 @@ nsCSSValue::BufferFromString(const nsStr
   // Null-terminate.
   data[length] = 0;
   return buffer.forget();
 }
 
 namespace {
 
 struct CSSValueSerializeCalcOps {
-  CSSValueSerializeCalcOps(nsCSSPropertyID aProperty, nsAString& aResult,
+  CSSValueSerializeCalcOps(nsCSSProperty aProperty, nsAString& aResult,
                            nsCSSValue::Serialization aSerialization)
     : mProperty(aProperty),
       mResult(aResult),
       mValueSerialization(aSerialization)
   {
   }
 
   typedef nsCSSValue input_type;
@@ -877,25 +877,25 @@ struct CSSValueSerializeCalcOps {
 
   void AppendNumber(const input_type& aValue)
   {
     MOZ_ASSERT(aValue.GetUnit() == eCSSUnit_Number, "unexpected unit");
     aValue.AppendToString(mProperty, mResult, mValueSerialization);
   }
 
 private:
-  nsCSSPropertyID mProperty;
+  nsCSSProperty mProperty;
   nsAString &mResult;
   nsCSSValue::Serialization mValueSerialization;
 };
 
 } // namespace
 
 void
-nsCSSValue::AppendPolygonToString(nsCSSPropertyID aProperty, nsAString& aResult,
+nsCSSValue::AppendPolygonToString(nsCSSProperty aProperty, nsAString& aResult,
                                   Serialization aSerialization) const
 {
   const nsCSSValue::Array* array = GetArrayValue();
   MOZ_ASSERT(array->Count() > 1 && array->Count() <= 3,
              "Polygons must have name and at least one more value.");
   // When the array has 2 elements, the item on index 1 is the coordinate
   // pair list.
   // When the array has 3 elements, the item on index 1 is a fill-rule
@@ -912,31 +912,31 @@ nsCSSValue::AppendPolygonToString(nsCSSP
     aResult.AppendLiteral(", ");
     ++index;
   }
   array->Item(index).AppendToString(aProperty, aResult, aSerialization);
 }
 
 inline void
 nsCSSValue::AppendPositionCoordinateToString(
-                const nsCSSValue& aValue, nsCSSPropertyID aProperty,
+                const nsCSSValue& aValue, nsCSSProperty aProperty,
                 nsAString& aResult, Serialization aSerialization) const
 {
   if (aValue.GetUnit() == eCSSUnit_Enumerated) {
     int32_t intValue = aValue.GetIntValue();
     AppendASCIItoUTF16(nsCSSProps::ValueToKeyword(intValue,
                           nsCSSProps::kShapeRadiusKTable), aResult);
   } else {
     aValue.AppendToString(aProperty, aResult, aSerialization);
   }
 }
 
 void
 nsCSSValue::AppendCircleOrEllipseToString(nsCSSKeyword aFunctionId,
-                                          nsCSSPropertyID aProperty,
+                                          nsCSSProperty aProperty,
                                           nsAString& aResult,
                                           Serialization aSerialization) const
 {
   const nsCSSValue::Array* array = GetArrayValue();
   size_t count = aFunctionId == eCSSKeyword_circle ? 2 : 3;
   MOZ_ASSERT(array->Count() == count + 1, "wrong number of arguments");
 
   bool hasRadii = array->Item(1).GetUnit() != eCSSUnit_Null;
@@ -1022,17 +1022,17 @@ nsCSSValue::AppendBasicShapePositionToSt
     aResult.Append(' ');
     yOffset.AppendToString(eCSSProperty_UNKNOWN, aResult, aSerialization);
   }
 }
 
 // Helper to append |aString| with the shorthand sides notation used in e.g.
 // 'padding'. |aProperties| and |aValues| are expected to have 4 elements.
 /*static*/ void
-nsCSSValue::AppendSidesShorthandToString(const nsCSSPropertyID aProperties[],
+nsCSSValue::AppendSidesShorthandToString(const nsCSSProperty aProperties[],
                                          const nsCSSValue* aValues[],
                                          nsAString& aString,
                                          nsCSSValue::Serialization
                                             aSerialization)
 {
   const nsCSSValue& value1 = *aValues[0];
   const nsCSSValue& value2 = *aValues[1];
   const nsCSSValue& value3 = *aValues[2];
@@ -1053,17 +1053,17 @@ nsCSSValue::AppendSidesShorthandToString
         MOZ_ASSERT(value4.GetUnit() != eCSSUnit_Null, "null value 4");
         value4.AppendToString(aProperties[3], aString, aSerialization);
       }
     }
   }
 }
 
 /*static*/ void
-nsCSSValue::AppendBasicShapeRadiusToString(const nsCSSPropertyID aProperties[],
+nsCSSValue::AppendBasicShapeRadiusToString(const nsCSSProperty aProperties[],
                                            const nsCSSValue* aValues[],
                                            nsAString& aResult,
                                            Serialization aSerialization)
 {
   bool needY = false;
   const nsCSSValue* xVals[4];
   const nsCSSValue* yVals[4];
   for (int i = 0; i < 4; i++) {
@@ -1079,17 +1079,17 @@ nsCSSValue::AppendBasicShapeRadiusToStri
   AppendSidesShorthandToString(aProperties, xVals, aResult, aSerialization);
   if (needY) {
     aResult.AppendLiteral(" / ");
     AppendSidesShorthandToString(aProperties, yVals, aResult, aSerialization);
   }
 }
 
 void
-nsCSSValue::AppendInsetToString(nsCSSPropertyID aProperty, nsAString& aResult,
+nsCSSValue::AppendInsetToString(nsCSSProperty aProperty, nsAString& aResult,
                                 Serialization aSerialization) const
 {
   const nsCSSValue::Array* array = GetArrayValue();
   MOZ_ASSERT(array->Count() == 6,
              "inset function has wrong number of arguments");
   if (array->Item(1).GetUnit() != eCSSUnit_Null) {
     array->Item(1).AppendToString(aProperty, aResult, aSerialization);
     if (array->Item(2).GetUnit() != eCSSUnit_Null) {
@@ -1102,17 +1102,17 @@ nsCSSValue::AppendInsetToString(nsCSSPro
           aResult.Append(' ');
           array->Item(4).AppendToString(aProperty, aResult, aSerialization);
         }
       }
     }
   }
 
   if (array->Item(5).GetUnit() == eCSSUnit_Array) {
-    const nsCSSPropertyID* subprops =
+    const nsCSSProperty* subprops =
       nsCSSProps::SubpropertyEntryFor(eCSSProperty_border_radius);
     const nsCSSValue::Array* radius = array->Item(5).GetArrayValue();
     MOZ_ASSERT(radius->Count() == 4, "expected 4 radii values");
     const nsCSSValue* vals[4] = {
       &(radius->Item(0)),
       &(radius->Item(1)),
       &(radius->Item(2)),
       &(radius->Item(3))
@@ -1152,17 +1152,17 @@ nsCSSValue::AppendAlignJustifyValueToStr
   if (MOZ_UNLIKELY(overflowPos == NS_STYLE_ALIGN_SAFE)) {
     aResult.Append(' ');
     AppendASCIItoUTF16(nsCSSProps::ValueToKeyword(overflowPos, kwtable),
                        aResult);
   }
 }
 
 void
-nsCSSValue::AppendToString(nsCSSPropertyID aProperty, nsAString& aResult,
+nsCSSValue::AppendToString(nsCSSProperty aProperty, nsAString& aResult,
                            Serialization aSerialization) const
 {
   // eCSSProperty_UNKNOWN gets used for some recursive calls below.
   MOZ_ASSERT((0 <= aProperty &&
               aProperty <= eCSSProperty_COUNT_no_shorthands) ||
              aProperty == eCSSProperty_UNKNOWN,
              "property ID out of range");
 
@@ -1225,17 +1225,17 @@ nsCSSValue::AppendToString(nsCSSProperty
         int32_t system = array->Item(i).GetIntValue();
         if (system != NS_STYLE_COUNTER_SYSTEM_SYMBOLIC) {
           AppendASCIItoUTF16(nsCSSProps::ValueToKeyword(
                   system, nsCSSProps::kCounterSystemKTable), aResult);
           mark = true;
         }
         continue;
       }
-      nsCSSPropertyID prop =
+      nsCSSProperty prop =
         ((eCSSUnit_Counter <= unit && unit <= eCSSUnit_Counters) &&
          i == array->Count() - 1)
         ? eCSSProperty_list_style_type : aProperty;
       if (array->Item(i).GetUnit() != eCSSUnit_Null) {
         array->Item(i).AppendToString(prop, aResult, aSerialization);
         mark = true;
       }
     }
@@ -1738,17 +1738,17 @@ nsCSSValue::AppendToString(nsCSSProperty
       if (++i == gradient->mStops.Length()) {
         break;
       }
       aResult.AppendLiteral(", ");
     }
 
     aResult.Append(')');
   } else if (eCSSUnit_TokenStream == unit) {
-    nsCSSPropertyID shorthand = mValue.mTokenStream->mShorthandPropertyID;
+    nsCSSProperty shorthand = mValue.mTokenStream->mShorthandPropertyID;
     if (shorthand == eCSSProperty_UNKNOWN ||
         nsCSSProps::PropHasFlags(shorthand, CSS_PROPERTY_IS_ALIAS) ||
         aProperty == eCSSProperty__x_system_font) {
       // We treat serialization of aliases like '-moz-transform' as a special
       // case, since it really wants to be serialized as if it were a longhand
       // even though it is implemented as a shorthand. We also need to
       // serialize -x-system-font's token stream value, even though the
       // value is set through the font shorthand.  This serialization
@@ -2114,17 +2114,17 @@ nsCSSValueList::CloneInto(nsCSSValueList
 {
   NS_ASSERTION(!aList->mNext, "Must be an empty list!");
   aList->mValue = mValue;
   aList->mNext = mNext ? mNext->Clone() : nullptr;
 }
 
 static void
 AppendValueListToString(const nsCSSValueList* val,
-                        nsCSSPropertyID aProperty, nsAString& aResult,
+                        nsCSSProperty aProperty, nsAString& aResult,
                         nsCSSValue::Serialization aSerialization)
 {
   for (;;) {
     val->mValue.AppendToString(aProperty, aResult, aSerialization);
     val = val->mNext;
     if (!val)
       break;
 
@@ -2132,17 +2132,17 @@ AppendValueListToString(const nsCSSValue
                                  CSS_PROPERTY_VALUE_LIST_USES_COMMAS))
       aResult.Append(char16_t(','));
     aResult.Append(char16_t(' '));
   }
 }
 
 static void
 AppendGridTemplateToString(const nsCSSValueList* val,
-                           nsCSSPropertyID aProperty, nsAString& aResult,
+                           nsCSSProperty aProperty, nsAString& aResult,
                            nsCSSValue::Serialization aSerialization)
 {
   // This is called for the "list" that's the top-level value of the property.
   bool isSubgrid = false;
   for (;;) {
     bool addSpaceSeparator = true;
     nsCSSUnit unit = val->mValue.GetUnit();
 
@@ -2225,17 +2225,17 @@ AppendGridTemplateToString(const nsCSSVa
 
     if (addSpaceSeparator) {
       aResult.Append(char16_t(' '));
     }
   }
 }
 
 void
-nsCSSValueList::AppendToString(nsCSSPropertyID aProperty, nsAString& aResult,
+nsCSSValueList::AppendToString(nsCSSProperty aProperty, nsAString& aResult,
                                nsCSSValue::Serialization aSerialization) const
 {
   if (aProperty == eCSSProperty_grid_template_columns ||
       aProperty == eCSSProperty_grid_template_rows) {
     AppendGridTemplateToString(this, aProperty, aResult, aSerialization);
   } else {
     AppendValueListToString(this, aProperty, aResult, aSerialization);
   }
@@ -2290,17 +2290,17 @@ nsCSSValueSharedList::~nsCSSValueSharedL
   MOZ_COUNT_DTOR(nsCSSValueSharedList);
   if (mHead) {
     NS_CSS_DELETE_LIST_MEMBER(nsCSSValueList, mHead, mNext);
     delete mHead;
   }
 }
 
 void
-nsCSSValueSharedList::AppendToString(nsCSSPropertyID aProperty, nsAString& aResult,
+nsCSSValueSharedList::AppendToString(nsCSSProperty aProperty, nsAString& aResult,
                                      nsCSSValue::Serialization aSerialization) const
 {
   if (mHead) {
     mHead->AppendToString(aProperty, aResult, aSerialization);
   }
 }
 
 bool
@@ -2338,17 +2338,17 @@ nsCSSRect::nsCSSRect(const nsCSSRect& aC
 }
 
 nsCSSRect::~nsCSSRect()
 {
   MOZ_COUNT_DTOR(nsCSSRect);
 }
 
 void
-nsCSSRect::AppendToString(nsCSSPropertyID aProperty, nsAString& aResult,
+nsCSSRect::AppendToString(nsCSSProperty aProperty, nsAString& aResult,
                           nsCSSValue::Serialization aSerialization) const
 {
   MOZ_ASSERT(mTop.GetUnit() != eCSSUnit_Null &&
              mTop.GetUnit() != eCSSUnit_Inherit &&
              mTop.GetUnit() != eCSSUnit_Initial &&
              mTop.GetUnit() != eCSSUnit_Unset,
              "parser should have used a bare value");
 
@@ -2411,17 +2411,17 @@ static_assert(NS_SIDE_TOP == 0 && NS_SID
   &nsCSSRect::mRight,
   &nsCSSRect::mBottom,
   &nsCSSRect::mLeft,
 };
 
 // --- nsCSSValuePair -----------------
 
 void
-nsCSSValuePair::AppendToString(nsCSSPropertyID aProperty,
+nsCSSValuePair::AppendToString(nsCSSProperty aProperty,
                                nsAString& aResult,
                                nsCSSValue::Serialization aSerialization) const
 {
   mXValue.AppendToString(aProperty, aResult, aSerialization);
   if (mYValue.GetUnit() != eCSSUnit_Null) {
     aResult.Append(char16_t(' '));
     mYValue.AppendToString(aProperty, aResult, aSerialization);
   }
@@ -2447,17 +2447,17 @@ nsCSSValuePair_heap::SizeOfIncludingThis
     n += mYValue.SizeOfExcludingThis(aMallocSizeOf);
   }
   return n;
 }
 
 // --- nsCSSValueTriplet -----------------
 
 void
-nsCSSValueTriplet::AppendToString(nsCSSPropertyID aProperty,
+nsCSSValueTriplet::AppendToString(nsCSSProperty aProperty,
                                   nsAString& aResult,
                                   nsCSSValue::Serialization aSerialization) const
 {
   mXValue.AppendToString(aProperty, aResult, aSerialization);
   if (mYValue.GetUnit() != eCSSUnit_Null) {
     aResult.Append(char16_t(' '));
     mYValue.AppendToString(aProperty, aResult, aSerialization);
     if (mZValue.GetUnit() != eCSSUnit_Null) {
@@ -2501,17 +2501,17 @@ nsCSSValuePairList::Clone() const
     src = src->mNext;
   }
 
   MOZ_ASSERT(result, "shouldn't return null; supposed to be infallible");
   return result;
 }
 
 void
-nsCSSValuePairList::AppendToString(nsCSSPropertyID aProperty,
+nsCSSValuePairList::AppendToString(nsCSSProperty aProperty,
                                    nsAString& aResult,
                                    nsCSSValue::Serialization aSerialization) const
 {
   const nsCSSValuePairList* item = this;
   for (;;) {
     MOZ_ASSERT(item->mXValue.GetUnit() != eCSSUnit_Null,
                "unexpected null unit");
     item->mXValue.AppendToString(aProperty, aResult, aSerialization);
--- a/layout/style/nsCSSValue.h
+++ b/layout/style/nsCSSValue.h
@@ -14,17 +14,17 @@
 #include "mozilla/MemoryReporting.h"
 #include "mozilla/SheetType.h"
 #include "mozilla/UniquePtr.h"
 
 #include "nsIPrincipal.h"
 #include "nsIURI.h"
 #include "nsCOMPtr.h"
 #include "nsCSSKeywords.h"
-#include "nsCSSPropertyID.h"
+#include "nsCSSProperty.h"
 #include "nsCSSProps.h"
 #include "nsColor.h"
 #include "nsCoord.h"
 #include "nsProxyRelease.h"
 #include "nsRefPtrHashtable.h"
 #include "nsString.h"
 #include "nsStringBuffer.h"
 #include "nsTArray.h"
@@ -486,17 +486,17 @@ public:
 
   // Enum for AppendToString's aValueSerialization argument.
   enum Serialization { eNormalized, eAuthorSpecified };
 
   /**
    * Serialize |this| as a specified value for |aProperty| and append
    * it to |aResult|.
    */
-  void AppendToString(nsCSSPropertyID aProperty, nsAString& aResult,
+  void AppendToString(nsCSSProperty aProperty, nsAString& aResult,
                       Serialization aValueSerialization) const;
 
   nsCSSUnit GetUnit() const { return mUnit; }
   bool      IsLengthUnit() const
     { return eCSSUnit_PhysicalMillimeter <= mUnit && mUnit <= eCSSUnit_Pixel; }
   bool      IsLengthPercentCalcUnit() const
     { return IsLengthUnit() || mUnit == eCSSUnit_Percent || IsCalcUnit(); }
   /**
@@ -795,47 +795,47 @@ public:
   // Returns an already addrefed buffer.  Guaranteed to return non-null.
   // (Will abort on allocation failure.)
   static already_AddRefed<nsStringBuffer>
     BufferFromString(const nsString& aValue);
 
   size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
 
   static void
-  AppendSidesShorthandToString(const nsCSSPropertyID aProperties[],
+  AppendSidesShorthandToString(const nsCSSProperty aProperties[],
                                const nsCSSValue* aValues[],
                                nsAString& aString,
                                Serialization aSerialization);
   static void
-  AppendBasicShapeRadiusToString(const nsCSSPropertyID aProperties[],
+  AppendBasicShapeRadiusToString(const nsCSSProperty aProperties[],
                                  const nsCSSValue* aValues[],
                                  nsAString& aResult,
                                  Serialization aValueSerialization);
   static void
   AppendAlignJustifyValueToString(int32_t aValue, nsAString& aResult);
 
 private:
   static const char16_t* GetBufferValue(nsStringBuffer* aBuffer) {
     return static_cast<char16_t*>(aBuffer->Data());
   }
 
-  void AppendPolygonToString(nsCSSPropertyID aProperty, nsAString& aResult,
+  void AppendPolygonToString(nsCSSProperty aProperty, nsAString& aResult,
                              Serialization aValueSerialization) const;
   void AppendPositionCoordinateToString(const nsCSSValue& aValue,
-                                        nsCSSPropertyID aProperty,
+                                        nsCSSProperty aProperty,
                                         nsAString& aResult,
                                         Serialization aSerialization) const;
   void AppendCircleOrEllipseToString(
            nsCSSKeyword aFunctionId,
-           nsCSSPropertyID aProperty, nsAString& aResult,
+           nsCSSProperty aProperty, nsAString& aResult,
            Serialization aValueSerialization) const;
   void AppendBasicShapePositionToString(
            nsAString& aResult,
            Serialization aValueSerialization) const;
-  void AppendInsetToString(nsCSSPropertyID aProperty, nsAString& aResult,
+  void AppendInsetToString(nsCSSProperty aProperty, nsAString& aResult,
                            Serialization aValueSerialization) const;
 protected:
   nsCSSUnit mUnit;
   union {
     int32_t    mInt;
     float      mFloat;
     // Note: the capacity of the buffer may exceed the length of the string.
     // If we're of a string type, mString is not null.
@@ -971,17 +971,17 @@ private:
 
 // Prefer nsCSSValue::Array for lists of fixed size.
 struct nsCSSValueList {
   nsCSSValueList() : mNext(nullptr) { MOZ_COUNT_CTOR(nsCSSValueList); }
   ~nsCSSValueList();
 
   nsCSSValueList* Clone() const;  // makes a deep copy. Infallible.
   void CloneInto(nsCSSValueList* aList) const; // makes a deep copy into aList
-  void AppendToString(nsCSSPropertyID aProperty, nsAString& aResult,
+  void AppendToString(nsCSSProperty aProperty, nsAString& aResult,
                       nsCSSValue::Serialization aValueSerialization) const;
 
   static bool Equal(const nsCSSValueList* aList1,
                     const nsCSSValueList* aList2);
 
   size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
 
   nsCSSValue      mValue;
@@ -1036,17 +1036,17 @@ struct nsCSSValueSharedList final {
 
 private:
   // Private destructor, to discourage deletion outside of Release():
   ~nsCSSValueSharedList();
 
 public:
   NS_INLINE_DECL_REFCOUNTING(nsCSSValueSharedList)
 
-  void AppendToString(nsCSSPropertyID aProperty, nsAString& aResult,
+  void AppendToString(nsCSSProperty aProperty, nsAString& aResult,
                       nsCSSValue::Serialization aValueSerialization) const;
 
   bool operator==(nsCSSValueSharedList const& aOther) const;
   bool operator!=(const nsCSSValueSharedList& aOther) const
   { return !(*this == aOther); }
 
   size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
 
@@ -1077,17 +1077,17 @@ nsCSSValue::GetListValue() const
   }
 }
 
 struct nsCSSRect {
   nsCSSRect(void);
   nsCSSRect(const nsCSSRect& aCopy);
   ~nsCSSRect();
 
-  void AppendToString(nsCSSPropertyID aProperty, nsAString& aResult,
+  void AppendToString(nsCSSProperty aProperty, nsAString& aResult,
                       nsCSSValue::Serialization aValueSerialization) const;
 
   bool operator==(const nsCSSRect& aOther) const {
     return mTop == aOther.mTop &&
            mRight == aOther.mRight &&
            mBottom == aOther.mBottom &&
            mLeft == aOther.mLeft;
   }
@@ -1219,17 +1219,17 @@ struct nsCSSValuePair {
     mYValue.Reset();
   }
 
   bool HasValue() const {
     return mXValue.GetUnit() != eCSSUnit_Null ||
            mYValue.GetUnit() != eCSSUnit_Null;
   }
 
-  void AppendToString(nsCSSPropertyID aProperty, nsAString& aResult,
+  void AppendToString(nsCSSProperty aProperty, nsAString& aResult,
                       nsCSSValue::Serialization aValueSerialization) const;
 
   size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
 
   nsCSSValue mXValue;
   nsCSSValue mYValue;
 };
 
@@ -1311,17 +1311,17 @@ struct nsCSSValueTriplet {
     }
 
     bool HasValue() const {
         return mXValue.GetUnit() != eCSSUnit_Null ||
                mYValue.GetUnit() != eCSSUnit_Null ||
                mZValue.GetUnit() != eCSSUnit_Null;
     }
 
-    void AppendToString(nsCSSPropertyID aProperty, nsAString& aResult,
+    void AppendToString(nsCSSProperty aProperty, nsAString& aResult,
                         nsCSSValue::Serialization aValueSerialization) const;
 
     nsCSSValue mXValue;
     nsCSSValue mYValue;
     nsCSSValue mZValue;
 };
 
 // nsCSSValueTriplet_heap differs from nsCSSValueTriplet only in being
@@ -1375,17 +1375,17 @@ nsCSSValue::GetTripletValue() const
 }
 
 // Maybe should be replaced with nsCSSValueList and nsCSSValue::Array?
 struct nsCSSValuePairList {
   nsCSSValuePairList() : mNext(nullptr) { MOZ_COUNT_CTOR(nsCSSValuePairList); }
   ~nsCSSValuePairList();
 
   nsCSSValuePairList* Clone() const; // makes a deep copy. Infallible.
-  void AppendToString(nsCSSPropertyID aProperty, nsAString& aResult,
+  void AppendToString(nsCSSProperty aProperty, nsAString& aResult,
                       nsCSSValue::Serialization aValueSerialization) const;
 
   static bool Equal(const nsCSSValuePairList* aList1,
                     const nsCSSValuePairList* aList2);
 
   size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
 
   nsCSSValue          mXValue;
@@ -1628,22 +1628,22 @@ public:
   NS_INLINE_DECL_REFCOUNTING(nsCSSValueTokenStream)
 
   size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
 
   // The property that has mTokenStream as its unparsed specified value.
   // When a variable reference is used in a shorthand property, a
   // TokenStream value is stored as the specified value for each of its
   // component longhand properties.
-  nsCSSPropertyID mPropertyID;
+  nsCSSProperty mPropertyID;
 
   // The shorthand property that had a value with a variable reference,
   // which caused the longhand property identified by mPropertyID to have
   // a TokenStream value.
-  nsCSSPropertyID mShorthandPropertyID;
+  nsCSSProperty mShorthandPropertyID;
 
   // The unparsed CSS corresponding to the specified value of the property.
   // When the value of a shorthand property has a variable reference, the
   // same mTokenStream value is used on each of the nsCSSValueTokenStream
   // objects that will be set by parsing the shorthand.
   nsString mTokenStream;
 
   nsCOMPtr<nsIURI> mBaseURI;
--- a/layout/style/nsComputedDOMStyle.cpp
+++ b/layout/style/nsComputedDOMStyle.cpp
@@ -82,17 +82,17 @@ struct nsComputedStyleMap
 {
   friend class nsComputedDOMStyle;
 
   struct Entry
   {
     // Create a pointer-to-member-function type.
     typedef already_AddRefed<CSSValue> (nsComputedDOMStyle::*ComputeMethod)();
 
-    nsCSSPropertyID mProperty;
+    nsCSSProperty mProperty;
     ComputeMethod mGetter;
 
     bool IsLayoutFlushNeeded() const
     {
       return nsCSSProps::PropHasFlags(mProperty,
                                       CSS_PROPERTY_GETCS_NEEDS_LAYOUT_FLUSH);
     }
 
@@ -123,28 +123,28 @@ struct nsComputedStyleMap
     return mExposedPropertyCount;
   }
 
   /**
    * Returns the property at the given index in the list of properties
    * that should be exposed on an nsComputedDOMStyle, excluding any
    * disabled properties.
    */
-  nsCSSPropertyID PropertyAt(uint32_t aIndex)
+  nsCSSProperty PropertyAt(uint32_t aIndex)
   {
     Update();
     return kEntries[EntryIndex(aIndex)].mProperty;
   }
 
   /**
    * Searches for and returns the computed style map entry for the given
    * property, or nullptr if the property is not exposed on nsComputedDOMStyle
    * or is currently disabled.
    */
-  const Entry* FindEntryForProperty(nsCSSPropertyID aPropID)
+  const Entry* FindEntryForProperty(nsCSSProperty aPropID)
   {
     Update();
     for (uint32_t i = 0; i < mExposedPropertyCount; i++) {
       const Entry* entry = &kEntries[EntryIndex(i)];
       if (entry->mProperty == aPropID) {
         return entry;
       }
     }
@@ -303,29 +303,29 @@ NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(
   NS_INTERFACE_MAP_ENTRY(nsIMutationObserver)
 NS_INTERFACE_MAP_END_INHERITING(nsDOMCSSDeclaration)
 
 
 NS_IMPL_CYCLE_COLLECTING_ADDREF(nsComputedDOMStyle)
 NS_IMPL_CYCLE_COLLECTING_RELEASE(nsComputedDOMStyle)
 
 NS_IMETHODIMP
-nsComputedDOMStyle::GetPropertyValue(const nsCSSPropertyID aPropID,
+nsComputedDOMStyle::GetPropertyValue(const nsCSSProperty aPropID,
                                      nsAString& aValue)
 {
   // This is mostly to avoid code duplication with GetPropertyCSSValue(); if
   // perf ever becomes an issue here (doubtful), we can look into changing
   // this.
   return GetPropertyValue(
     NS_ConvertASCIItoUTF16(nsCSSProps::GetStringValue(aPropID)),
     aValue);
 }
 
 NS_IMETHODIMP
-nsComputedDOMStyle::SetPropertyValue(const nsCSSPropertyID aPropID,
+nsComputedDOMStyle::SetPropertyValue(const nsCSSProperty aPropID,
                                      const nsAString& aValue)
 {
   return NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR;
 }
 
 NS_IMETHODIMP
 nsComputedDOMStyle::GetCssText(nsAString& aCssText)
 {
@@ -748,34 +748,34 @@ nsComputedDOMStyle::ClearCurrentStyleSou
   if (!mResolvedStyleContext) {
     mStyleContext = nullptr;
   }
 }
 
 already_AddRefed<CSSValue>
 nsComputedDOMStyle::GetPropertyCSSValue(const nsAString& aPropertyName, ErrorResult& aRv)
 {
-  nsCSSPropertyID prop =
+  nsCSSProperty prop =
     nsCSSProps::LookupProperty(aPropertyName, CSSEnabledState::eForAllContent);
 
   bool needsLayoutFlush;
   nsComputedStyleMap::Entry::ComputeMethod getter;
 
   if (prop == eCSSPropertyExtra_variable) {
     needsLayoutFlush = false;
     getter = nullptr;
   } else {
     // We don't (for now, anyway, though it may make sense to change it
     // for all aliases, including those in nsCSSPropAliasList) want
     // aliases to be enumerable (via GetLength and IndexedGetter), so
     // handle them here rather than adding entries to
     // GetQueryablePropertyMap.
     if (prop != eCSSProperty_UNKNOWN &&
         nsCSSProps::PropHasFlags(prop, CSS_PROPERTY_IS_ALIAS)) {
-      const nsCSSPropertyID* subprops = nsCSSProps::SubpropertyEntryFor(prop);
+      const nsCSSProperty* subprops = nsCSSProps::SubpropertyEntryFor(prop);
       MOZ_ASSERT(subprops[1] == eCSSProperty_UNKNOWN,
                  "must have list of length 1");
       prop = subprops[0];
     }
 
     const nsComputedStyleMap::Entry* propEntry =
       GetComputedStyleMap()->FindEntryForProperty(prop);
 
@@ -6317,17 +6317,17 @@ nsComputedDOMStyle::DoGetTransitionPrope
   RefPtr<nsDOMCSSValueList> valueList = GetROCSSValueList(true);
 
   MOZ_ASSERT(display->mTransitionPropertyCount > 0,
              "first item must be explicit");
   uint32_t i = 0;
   do {
     const StyleTransition *transition = &display->mTransitions[i];
     RefPtr<nsROCSSPrimitiveValue> property = new nsROCSSPrimitiveValue;
-    nsCSSPropertyID cssprop = transition->GetProperty();
+    nsCSSProperty cssprop = transition->GetProperty();
     if (cssprop == eCSSPropertyExtra_all_properties)
       property->SetIdent(eCSSKeyword_all);
     else if (cssprop == eCSSPropertyExtra_no_properties)
       property->SetIdent(eCSSKeyword_none);
     else if (cssprop == eCSSProperty_UNKNOWN ||
              cssprop == eCSSPropertyExtra_variable)
     {
       nsAutoString escaped;
--- a/layout/style/nsComputedDOMStylePropertyList.h
+++ b/layout/style/nsComputedDOMStylePropertyList.h
@@ -14,17 +14,17 @@
   on nsComputedDOMStyle objects.  It is designed to be included in
   nsComputedDOMStyle.cpp to generate the "computed style map", a
   table of property IDs and corresponding functions on nsComputedDOMStyle
   that return the CSSValue representing that property's computed value.
 
   The COMPUTED_STYLE_PROP macro is defined for each such property.
   Its arguments are:
 
-  -. 'id' the nsCSSPropertyID ID, without the leading "nsCSSProperty_".
+  -. 'id' the nsCSSProperty ID, without the leading "nsCSSProperty_".
 
   -. 'method' the nsComputedDOMStyle method name that returns the
   CSSValue representing that property's computed value, without the leading
   "Do".
 
  ******/
 
 /* ******************************************************************* *\
--- a/layout/style/nsDOMCSSAttrDeclaration.cpp
+++ b/layout/style/nsDOMCSSAttrDeclaration.cpp
@@ -167,17 +167,17 @@ nsDOMCSSAttributeDeclaration::GetParentR
 
 /* virtual */ nsINode*
 nsDOMCSSAttributeDeclaration::GetParentObject()
 {
   return mElement;
 }
 
 NS_IMETHODIMP
-nsDOMCSSAttributeDeclaration::SetPropertyValue(const nsCSSPropertyID aPropID,
+nsDOMCSSAttributeDeclaration::SetPropertyValue(const nsCSSProperty aPropID,
                                                const nsAString& aValue)
 {
   // Scripted modifications to style.opacity or style.transform
   // could immediately force us into the animated state if heuristics suggest
   // this is scripted animation.
   // FIXME: This is missing the margin shorthand and the logical versions of
   // the margin properties, see bug 1266287.
   if (aPropID == eCSSProperty_opacity || aPropID == eCSSProperty_transform ||
--- a/layout/style/nsDOMCSSAttrDeclaration.h
+++ b/layout/style/nsDOMCSSAttrDeclaration.h
@@ -31,17 +31,17 @@ public:
   // If GetCSSDeclaration returns non-null, then the decl it returns
   // is owned by our current style rule.
   virtual mozilla::css::Declaration* GetCSSDeclaration(Operation aOperation) override;
   virtual void GetCSSParsingEnvironment(CSSParsingEnvironment& aCSSParseEnv) override;
   NS_IMETHOD GetParentRule(nsIDOMCSSRule **aParent) override;
 
   virtual nsINode* GetParentObject() override;
 
-  NS_IMETHOD SetPropertyValue(const nsCSSPropertyID aPropID,
+  NS_IMETHOD SetPropertyValue(const nsCSSProperty aPropID,
                               const nsAString& aValue) override;
 
 protected:
   ~nsDOMCSSAttributeDeclaration();
 
   virtual nsresult SetCSSDeclaration(mozilla::css::Declaration* aDecl) override;
   virtual nsIDocument* DocToUpdate() override;
 
--- a/layout/style/nsDOMCSSDeclaration.cpp
+++ b/layout/style/nsDOMCSSDeclaration.cpp
@@ -36,17 +36,17 @@ nsDOMCSSDeclaration::WrapObject(JSContex
 NS_INTERFACE_TABLE_HEAD(nsDOMCSSDeclaration)
   NS_INTERFACE_TABLE(nsDOMCSSDeclaration,
                      nsICSSDeclaration,
                      nsIDOMCSSStyleDeclaration)
   NS_INTERFACE_TABLE_TO_MAP_SEGUE
 NS_INTERFACE_MAP_END
 
 NS_IMETHODIMP
-nsDOMCSSDeclaration::GetPropertyValue(const nsCSSPropertyID aPropID,
+nsDOMCSSDeclaration::GetPropertyValue(const nsCSSProperty aPropID,
                                       nsAString& aValue)
 {
   NS_PRECONDITION(aPropID != eCSSProperty_UNKNOWN,
                   "Should never pass eCSSProperty_UNKNOWN around");
 
   css::Declaration* decl = GetCSSDeclaration(eOperation_Read);
 
   aValue.Truncate();
@@ -70,17 +70,17 @@ nsDOMCSSDeclaration::GetCustomPropertyVa
   }
 
   decl->GetVariableDeclaration(Substring(aPropertyName,
                                          CSS_CUSTOM_NAME_PREFIX_LENGTH),
                                aValue);
 }
 
 NS_IMETHODIMP
-nsDOMCSSDeclaration::SetPropertyValue(const nsCSSPropertyID aPropID,
+nsDOMCSSDeclaration::SetPropertyValue(const nsCSSProperty aPropID,
                                       const nsAString& aValue)
 {
   switch (aPropID) {
     case eCSSProperty_background_position:
     case eCSSProperty_background_position_x:
     case eCSSProperty_background_position_y:
     case eCSSProperty_transform:
     case eCSSProperty_top:
@@ -190,17 +190,17 @@ nsDOMCSSDeclaration::IndexedGetter(uint3
   css::Declaration* decl = GetCSSDeclaration(eOperation_Read);
   aFound = decl && decl->GetNthProperty(aIndex, aPropName);
 }
 
 NS_IMETHODIMP
 nsDOMCSSDeclaration::GetPropertyValue(const nsAString& aPropertyName,
                                       nsAString& aReturn)
 {
-  const nsCSSPropertyID propID =
+  const nsCSSProperty propID =
     nsCSSProps::LookupProperty(aPropertyName, CSSEnabledState::eForAllContent);
   if (propID == eCSSProperty_UNKNOWN) {
     aReturn.Truncate();
     return NS_OK;
   }
 
   if (propID == eCSSPropertyExtra_variable) {
     GetCustomPropertyValue(aPropertyName, aReturn);
@@ -209,17 +209,17 @@ nsDOMCSSDeclaration::GetPropertyValue(co
 
   return GetPropertyValue(propID, aReturn);
 }
 
 NS_IMETHODIMP
 nsDOMCSSDeclaration::GetAuthoredPropertyValue(const nsAString& aPropertyName,
                                               nsAString& aReturn)
 {
-  const nsCSSPropertyID propID =
+  const nsCSSProperty propID =
     nsCSSProps::LookupProperty(aPropertyName, CSSEnabledState::eForAllContent);
   if (propID == eCSSProperty_UNKNOWN) {
     aReturn.Truncate();
     return NS_OK;
   }
 
   if (propID == eCSSPropertyExtra_variable) {
     GetCustomPropertyValue(aPropertyName, aReturn);
@@ -250,17 +250,17 @@ nsDOMCSSDeclaration::GetPropertyPriority
 }
 
 NS_IMETHODIMP
 nsDOMCSSDeclaration::SetProperty(const nsAString& aPropertyName,
                                  const nsAString& aValue,
                                  const nsAString& aPriority)
 {
   // In the common (and fast) cases we can use the property id
-  nsCSSPropertyID propID =
+  nsCSSProperty propID =
     nsCSSProps::LookupProperty(aPropertyName, CSSEnabledState::eForAllContent);
   if (propID == eCSSProperty_UNKNOWN) {
     return NS_OK;
   }
 
   if (aValue.IsEmpty()) {
     // If the new value of the property is an empty string we remove the
     // property.
@@ -286,17 +286,17 @@ nsDOMCSSDeclaration::SetProperty(const n
   }
   return ParsePropertyValue(propID, aValue, important);
 }
 
 NS_IMETHODIMP
 nsDOMCSSDeclaration::RemoveProperty(const nsAString& aPropertyName,
                                     nsAString& aReturn)
 {
-  const nsCSSPropertyID propID =
+  const nsCSSProperty propID =
     nsCSSProps::LookupProperty(aPropertyName, CSSEnabledState::eForAllContent);
   if (propID == eCSSProperty_UNKNOWN) {
     aReturn.Truncate();
     return NS_OK;
   }
 
   if (propID == eCSSPropertyExtra_variable) {
     RemoveCustomProperty(aPropertyName);
@@ -322,17 +322,17 @@ nsDOMCSSDeclaration::GetCSSParsingEnviro
   nsIDocument* document = sheet->GetOwningDocument();
   aCSSParseEnv.mSheetURI = sheet->GetSheetURI();
   aCSSParseEnv.mBaseURI = sheet->GetBaseURI();
   aCSSParseEnv.mPrincipal = sheet->Principal();
   aCSSParseEnv.mCSSLoader = document ? document->CSSLoader() : nullptr;
 }
 
 nsresult
-nsDOMCSSDeclaration::ParsePropertyValue(const nsCSSPropertyID aPropID,
+nsDOMCSSDeclaration::ParsePropertyValue(const nsCSSProperty aPropID,
                                         const nsAString& aPropValue,
                                         bool aIsImportant)
 {
   css::Declaration* olddecl = GetCSSDeclaration(eOperation_Modify);
   if (!olddecl) {
     return NS_ERROR_NOT_AVAILABLE;
   }
 
@@ -399,17 +399,17 @@ nsDOMCSSDeclaration::ParseCustomProperty
     // Parsing failed -- but we don't throw an exception for that.
     return NS_OK;
   }
 
   return SetCSSDeclaration(decl);
 }
 
 nsresult
-nsDOMCSSDeclaration::RemoveProperty(const nsCSSPropertyID aPropID)
+nsDOMCSSDeclaration::RemoveProperty(const nsCSSProperty aPropID)
 {
   css::Declaration* olddecl = GetCSSDeclaration(eOperation_RemoveProperty);
   if (!olddecl) {
     return NS_OK; // no decl, so nothing to remove
   }
 
   // For nsDOMCSSAttributeDeclaration, SetCSSDeclaration will lead to
   // Attribute setting code, which leads in turn to BeginUpdate.  We
--- a/layout/style/nsDOMCSSDeclaration.h
+++ b/layout/style/nsDOMCSSDeclaration.h
@@ -151,23 +151,23 @@ protected:
   // anything meaningful.
   virtual void GetCSSParsingEnvironment(CSSParsingEnvironment& aCSSParseEnv) = 0;
 
   // An implementation for GetCSSParsingEnvironment for callers wrapping
   // an css::Rule.
   static void GetCSSParsingEnvironmentForRule(mozilla::css::Rule* aRule,
                                               CSSParsingEnvironment& aCSSParseEnv);
 
-  nsresult ParsePropertyValue(const nsCSSPropertyID aPropID,
+  nsresult ParsePropertyValue(const nsCSSProperty aPropID,
                               const nsAString& aPropValue,
                               bool aIsImportant);
 
   // Prop-id based version of RemoveProperty.  Note that this does not
   // return the old value; it just does a straight removal.
-  nsresult RemoveProperty(const nsCSSPropertyID aPropID);
+  nsresult RemoveProperty(const nsCSSProperty aPropID);
 
   void GetCustomPropertyValue(const nsAString& aPropertyName, nsAString& aValue);
   nsresult RemoveCustomProperty(const nsAString& aPropertyName);
   nsresult ParseCustomPropertyValue(const nsAString& aPropertyName,
                                     const nsAString& aPropValue,
                                     bool aIsImportant);
 
 protected:
--- a/layout/style/nsICSSDeclaration.h
+++ b/layout/style/nsICSSDeclaration.h
@@ -9,24 +9,24 @@
  */
 
 #ifndef nsICSSDeclaration_h__
 #define nsICSSDeclaration_h__
 
 /**
  * This interface provides access to methods analogous to those of
  * nsIDOMCSSStyleDeclaration; the difference is that these use
- * nsCSSPropertyID enums for the prop names instead of using strings.
+ * nsCSSProperty enums for the prop names instead of using strings.
  * This is meant for use in performance-sensitive code only!  Most
  * consumers should continue to use nsIDOMCSSStyleDeclaration.
  */
 
 #include "mozilla/Attributes.h"
 #include "nsIDOMCSSStyleDeclaration.h"
-#include "nsCSSPropertyID.h"
+#include "nsCSSProperty.h"
 #include "CSSValue.h"
 #include "nsWrapperCache.h"
 #include "nsString.h"
 #include "nsIDOMCSSRule.h"
 #include "nsIDOMCSSValue.h"
 #include "mozilla/ErrorResult.h"
 #include "nsCOMPtr.h"
 
@@ -42,28 +42,28 @@ class nsICSSDeclaration : public nsIDOMC
 {
 public:
   NS_DECLARE_STATIC_IID_ACCESSOR(NS_ICSSDECLARATION_IID)
 
   /**
    * Method analogous to nsIDOMCSSStyleDeclaration::GetPropertyValue,
    * which obeys all the same restrictions.
    */
-  NS_IMETHOD GetPropertyValue(const nsCSSPropertyID aPropID,
+  NS_IMETHOD GetPropertyValue(const nsCSSProperty aPropID,
                               nsAString& aValue) = 0;
 
   NS_IMETHOD GetAuthoredPropertyValue(const nsAString& aPropName,
                                       nsAString& aValue) = 0;
 
   /**
    * Method analogous to nsIDOMCSSStyleDeclaration::SetProperty.  This
    * method does NOT allow setting a priority (the priority will
    * always be set to default priority).
    */
-  NS_IMETHOD SetPropertyValue(const nsCSSPropertyID aPropID,
+  NS_IMETHOD SetPropertyValue(const nsCSSProperty aPropID,
                               const nsAString& aValue) = 0;
 
   virtual nsINode *GetParentObject() = 0;
 
   // Also have to declare all the nsIDOMCSSStyleDeclaration methods,
   // since we want to be able to call them from the WebIDL versions.
   NS_IMETHOD GetCssText(nsAString& aCssText) override = 0;
   NS_IMETHOD SetCssText(const nsAString& aCssText) override = 0;
@@ -148,21 +148,21 @@ public:
     GetParentRule(getter_AddRefs(rule));
     return rule.forget();
   }
 };
 
 NS_DEFINE_STATIC_IID_ACCESSOR(nsICSSDeclaration, NS_ICSSDECLARATION_IID)
 
 #define NS_DECL_NSICSSDECLARATION                                   \
-  NS_IMETHOD GetPropertyValue(const nsCSSPropertyID aPropID,          \
+  NS_IMETHOD GetPropertyValue(const nsCSSProperty aPropID,          \
                               nsAString& aValue) override;          \
   NS_IMETHOD GetAuthoredPropertyValue(const nsAString& aPropName,   \
                                       nsAString& aValue) override;  \
-  NS_IMETHOD SetPropertyValue(const nsCSSPropertyID aPropID,          \
+  NS_IMETHOD SetPropertyValue(const nsCSSProperty aPropID,          \
                               const nsAString& aValue) override;
 
 #define NS_DECL_NSIDOMCSSSTYLEDECLARATION_HELPER \
   NS_IMETHOD GetCssText(nsAString & aCssText) override; \
   NS_IMETHOD SetCssText(const nsAString & aCssText) override; \
   NS_IMETHOD GetPropertyValue(const nsAString & propertyName, nsAString & _retval) override; \
   NS_IMETHOD RemoveProperty(const nsAString & propertyName, nsAString & _retval) override; \
   NS_IMETHOD GetPropertyPriority(const nsAString & propertyName, nsAString & _retval) override; \
--- a/layout/style/nsIStyleRule.h
+++ b/layout/style/nsIStyleRule.h
@@ -8,17 +8,17 @@
  * information
  */
 
 #ifndef nsIStyleRule_h___
 #define nsIStyleRule_h___
 
 #include <stdio.h>
 
-#include "nsCSSPropertyID.h"
+#include "nsCSSProperty.h"
 #include "nsISupports.h"
 
 class nsCSSValue;
 struct nsRuleData;
 
 // IID for the nsIStyleRule interface {f75f3f70-435d-43a6-a01b-65970489ca26}
 #define NS_ISTYLE_RULE_IID     \
 { 0xf75f3f70, 0x435d, 0x43a6, \
@@ -78,17 +78,17 @@ public:
    * properties.
    */
   virtual bool MightMapInheritedStyleData() = 0;
 
   /**
    * Gets and sets given aProperty's value to aValue.
    * Returns true, if aValue is filled in this rule.
    */
-  virtual bool GetDiscretelyAnimatedCSSValue(nsCSSPropertyID aProperty,
+  virtual bool GetDiscretelyAnimatedCSSValue(nsCSSProperty aProperty,
                                              nsCSSValue* aValue) = 0;
 
 #ifdef DEBUG
   virtual void List(FILE* out = stdout, int32_t aIndent = 0) const = 0;
 #endif
 };
 
 NS_DEFINE_STATIC_IID_ACCESSOR(nsIStyleRule, NS_ISTYLE_RULE_IID)
--- a/layout/style/nsRuleData.h
+++ b/layout/style/nsRuleData.h
@@ -61,17 +61,17 @@ struct nsRuleData
 
   /**
    * Return a pointer to the value object within |this| corresponding
    * to property |aProperty|.
    *
    * This function must only be called if the given property is in
    * mSIDs.
    */
-  nsCSSValue* ValueFor(nsCSSPropertyID aProperty)
+  nsCSSValue* ValueFor(nsCSSProperty aProperty)
   {
     MOZ_ASSERT(aProperty < eCSSProperty_COUNT_no_shorthands,
                "invalid or shorthand property");
 
     nsStyleStructID sid = nsCSSProps::kSIDTable[aProperty];
     size_t indexInStruct = nsCSSProps::PropertyIndexInStruct(aProperty);
 
     // This should really be nsCachedStyleData::GetBitForSID, but we can't
@@ -79,17 +79,17 @@ struct nsRuleData
     MOZ_ASSERT(mSIDs & (1 << sid),
                "calling nsRuleData::ValueFor on property not in mSIDs");
     MOZ_ASSERT(indexInStruct != size_t(-1),
                "logical property");
 
     return mValueStorage + mValueOffsets[sid] + indexInStruct;
   }
 
-  const nsCSSValue* ValueFor(nsCSSPropertyID aProperty) const {
+  const nsCSSValue* ValueFor(nsCSSProperty aProperty) const {
     return const_cast<nsRuleData*>(this)->ValueFor(aProperty);
   }
 
   /**
    * Getters like ValueFor(aProperty), but for each property by name
    * (ValueForBackgroundColor, etc.), and more efficient than ValueFor.
    * These use the names used for the property on DOM interfaces (the
    * 'method' field in nsCSSPropList.h).
--- a/layout/style/nsRuleNode.cpp
+++ b/layout/style/nsRuleNode.cpp
@@ -48,17 +48,17 @@
 #include "nsPrintfCString.h"
 #include "nsRenderingContext.h"
 #include "nsStyleUtil.h"
 #include "nsIDocument.h"
 #include "prtime.h"
 #include "CSSVariableResolver.h"
 #include "nsCSSParser.h"
 #include "CounterStyleManager.h"
-#include "nsCSSPropertyIDSet.h"
+#include "nsCSSPropertySet.h"
 #include "mozilla/RuleNodeCacheConditions.h"
 #include "nsDeviceContext.h"
 #include "nsQueryObject.h"
 #include "nsUnicodeProperties.h"
 
 #if defined(_MSC_VER) || defined(__MINGW32__)
 #include <malloc.h>
 #ifdef _MSC_VER
@@ -5174,17 +5174,17 @@ nsRuleNode::ComputeUIResetData(void* aSt
            NS_STYLE_WINDOW_SHADOW_DEFAULT);
 
   COMPUTE_END_RESET(UIReset, ui)
 }
 
 // Information about each transition or animation property that is
 // constant.
 struct TransitionPropInfo {
-  nsCSSPropertyID property;
+  nsCSSProperty property;
   // Location of the count of the property's computed value.
   uint32_t nsStyleDisplay::* sdCount;
 };
 
 // Each property's index in this array must match its index in the
 // mutable array |transitionPropData| below.
 static const TransitionPropInfo transitionPropInfo[4] = {
   { eCSSProperty_transition_delay,
@@ -5347,17 +5347,17 @@ nsRuleNode::ComputeTimingFunction(const 
       }
       break;
     default:
       NS_NOTREACHED("Invalid transition property unit");
   }
 }
 
 static uint8_t
-GetWillChangeBitFieldFromPropFlags(const nsCSSPropertyID& aProp)
+GetWillChangeBitFieldFromPropFlags(const nsCSSProperty& aProp)
 {
   uint8_t willChangeBitField = 0;
   if (nsCSSProps::PropHasFlags(aProp, CSS_PROPERTY_CREATES_STACKING_CONTEXT)) {
     willChangeBitField |= NS_STYLE_WILL_CHANGE_STACKING_CONTEXT;
   }
 
   if (nsCSSProps::PropHasFlags(aProp, CSS_PROPERTY_FIXPOS_CB)) {
     willChangeBitField |= NS_STYLE_WILL_CHANGE_FIXPOS_CB;
@@ -5490,17 +5490,17 @@ nsRuleNode::ComputeDisplayData(void* aSt
     } else if (property.unit == eCSSUnit_None) {
       transition->SetProperty(eCSSPropertyExtra_no_properties);
     } else if (property.list) {
       const nsCSSValue &val = property.list->mValue;
 
       if (val.GetUnit() == eCSSUnit_Ident) {
         nsDependentString
           propertyStr(property.list->mValue.GetStringBufferValue());
-        nsCSSPropertyID prop =
+        nsCSSProperty prop =
           nsCSSProps::LookupProperty(propertyStr,
                                      CSSEnabledState::eForAllContent);
         if (prop == eCSSProperty_UNKNOWN ||
             prop == eCSSPropertyExtra_variable) {
           transition->SetUnknownProperty(prop, propertyStr);
         } else {
           transition->SetProperty(prop);
         }
@@ -6290,24 +6290,24 @@ nsRuleNode::ComputeDisplayData(void* aSt
         }
         if (buffer.EqualsLiteral("opacity")) {
           display->mWillChangeBitField |= NS_STYLE_WILL_CHANGE_OPACITY;
         }
         if (buffer.EqualsLiteral("scroll-position")) {
           display->mWillChangeBitField |= NS_STYLE_WILL_CHANGE_SCROLL;
         }
 
-        nsCSSPropertyID prop =
+        nsCSSProperty prop =
           nsCSSProps::LookupProperty(buffer, CSSEnabledState::eForAllContent);
         if (prop != eCSSProperty_UNKNOWN &&
             prop != eCSSPropertyExtra_variable) {
           // If the property given is a shorthand, it indicates the expectation
           // for all the longhands the shorthand expands to.
           if (nsCSSProps::IsShorthand(prop)) {
-            for (const nsCSSPropertyID* shorthands =
+            for (const nsCSSProperty* shorthands =
                    nsCSSProps::SubpropertyEntryFor(prop);
                  *shorthands != eCSSProperty_UNKNOWN; ++shorthands) {
               display->mWillChangeBitField |= GetWillChangeBitFieldFromPropFlags(*shorthands);
             }
           } else {
             display->mWillChangeBitField |= GetWillChangeBitFieldFromPropFlags(prop);
           }
         }
@@ -7331,17 +7331,17 @@ nsRuleNode::ComputeMarginData(void* aSta
                               nsStyleContext* aContext,
                               nsRuleNode* aHighestNode,
                               const RuleDetail aRuleDetail,
                               const RuleNodeCacheConditions aConditions)
 {
   COMPUTE_START_RESET(Margin, margin, parentMargin)
 
   // margin: length, percent, calc, inherit
-  const nsCSSPropertyID* subprops =
+  const nsCSSProperty* subprops =
     nsCSSProps::SubpropertyEntryFor(eCSSProperty_margin);
   nsStyleCoord coord;
   NS_FOR_CSS_SIDES(side) {
     nsStyleCoord parentCoord = parentMargin->mMargin.Get(side);
     if (SetCoord(*aRuleData->ValueFor(subprops[side]),
                  coord, parentCoord,
                  SETCOORD_LPAH | SETCOORD_INITIAL_ZERO | SETCOORD_STORE_CALC |
                    SETCOORD_UNSET_INITIAL,
@@ -7445,17 +7445,17 @@ nsRuleNode::ComputeBorderData(void* aSta
            border->mBoxDecorationBreak, conditions,
            SETVAL_ENUMERATED | SETVAL_UNSET_INITIAL,
            parentBorder->mBoxDecorationBreak,
            NS_STYLE_BOX_DECORATION_BREAK_SLICE);
 
   // border-width, border-*-width: length, enum, inherit
   nsStyleCoord coord;
   {
-    const nsCSSPropertyID* subprops =
+    const nsCSSProperty* subprops =
       nsCSSProps::SubpropertyEntryFor(eCSSProperty_border_width);
     NS_FOR_CSS_SIDES(side) {
       const nsCSSValue& value = *aRuleData->ValueFor(subprops[side]);
       NS_ASSERTION(eCSSUnit_Percent != value.GetUnit(),
                    "Percentage borders not implemented yet "
                    "If implementing, make sure to fix all consumers of "
                    "nsStyleBorder, the IsPercentageAwareChild method, "
                    "the nsAbsoluteContainingBlock::FrameDependsOnContainer "
@@ -7492,17 +7492,17 @@ nsRuleNode::ComputeBorderData(void* aSta
         NS_ASSERTION(eCSSUnit_Null == value.GetUnit(),
                      "missing case handling border width");
       }
     }
   }
 
   // border-style, border-*-style: enum, inherit
   {
-    const nsCSSPropertyID* subprops =
+    const nsCSSProperty* subprops =
       nsCSSProps::SubpropertyEntryFor(eCSSProperty_border_style);
     NS_FOR_CSS_SIDES(side) {
       const nsCSSValue& value = *aRuleData->ValueFor(subprops[side]);
       nsCSSUnit unit = value.GetUnit();
       MOZ_ASSERT(eCSSUnit_None != unit,
                  "'none' should be handled as enumerated value");
       if (eCSSUnit_Enumerated == unit) {
         border->SetBorderStyle(side, value.GetIntValue());
@@ -7517,17 +7517,17 @@ nsRuleNode::ComputeBorderData(void* aSta
       }
     }
   }
 
   // -moz-border-*-colors: color, string, enum, none, inherit/initial
   nscolor borderColor;
   nscolor unused = NS_RGB(0,0,0);
 
-  static const nsCSSPropertyID borderColorsProps[] = {
+  static const nsCSSProperty borderColorsProps[] = {
     eCSSProperty_border_top_colors,
     eCSSProperty_border_right_colors,
     eCSSProperty_border_bottom_colors,
     eCSSProperty_border_left_colors
   };
 
   NS_FOR_CSS_SIDES(side) {
     const nsCSSValue& value = *aRuleData->ValueFor(borderColorsProps[side]);
@@ -7576,17 +7576,17 @@ nsRuleNode::ComputeBorderData(void* aSta
 
     default:
       MOZ_ASSERT(false, "unrecognized border color unit");
     }
   }
 
   // border-color, border-*-color: color, string, enum, inherit
   {
-    const nsCSSPropertyID* subprops =
+    const nsCSSProperty* subprops =
       nsCSSProps::SubpropertyEntryFor(eCSSProperty_border_color);
     bool foreground;
     NS_FOR_CSS_SIDES(side) {
       const nsCSSValue& value = *aRuleData->ValueFor(subprops[side]);
       if (eCSSUnit_Inherit == value.GetUnit()) {
         conditions.SetUncacheable();
         if (parentContext) {
           parentBorder->GetBorderColor(side, borderColor, foreground);
@@ -7622,17 +7622,17 @@ nsRuleNode::ComputeBorderData(void* aSta
                eCSSUnit_Unset == value.GetUnit()) {
         border->SetBorderToForeground(side);
       }
     }
   }
 
   // border-radius: length, percent, inherit
   {
-    const nsCSSPropertyID* subprops =
+    const nsCSSProperty* subprops =
       nsCSSProps::SubpropertyEntryFor(eCSSProperty_border_radius);
     NS_FOR_CSS_FULL_CORNERS(corner) {
       int cx = NS_FULL_TO_HALF_CORNER(corner, false);
       int cy = NS_FULL_TO_HALF_CORNER(corner, true);
       const nsCSSValue& radius = *aRuleData->ValueFor(subprops[corner]);
       nsStyleCoord parentX = parentBorder->mBorderRadius.Get(cx);
       nsStyleCoord parentY = parentBorder->mBorderRadius.Get(cy);
       nsStyleCoord coordX, coordY;
@@ -7752,17 +7752,17 @@ nsRuleNode::ComputePaddingData(void* aSt
                                nsStyleContext* aContext,
                                nsRuleNode* aHighestNode,
                                const RuleDetail aRuleDetail,
                                const RuleNodeCacheConditions aConditions)
 {
   COMPUTE_START_RESET(Padding, padding, parentPadding)
 
   // padding: length, percent, calc, inherit
-  const nsCSSPropertyID* subprops =
+  const nsCSSProperty* subprops =
     nsCSSProps::SubpropertyEntryFor(eCSSProperty_padding);
   nsStyleCoord coord;
   NS_FOR_CSS_SIDES(side) {
     nsStyleCoord parentCoord = parentPadding->mPadding.Get(side);
     if (SetCoord(*aRuleData->ValueFor(subprops[side]),
                  coord, parentCoord,
                  SETCOORD_LPH | SETCOORD_INITIAL_ZERO | SETCOORD_STORE_CALC |
                    SETCOORD_UNSET_INITIAL,
@@ -7840,17 +7840,17 @@ nsRuleNode::ComputeOutlineData(void* aSt
   else if (eCSSUnit_Enumerated == outlineColorValue->GetUnit() ||
            eCSSUnit_Initial == outlineColorValue->GetUnit() ||
            eCSSUnit_Unset == outlineColorValue->GetUnit()) {
     outline->SetOutlineInitialColor();
   }
 
   // -moz-outline-radius: length, percent, inherit
   {
-    const nsCSSPropertyID* subprops =
+    const nsCSSProperty* subprops =
       nsCSSProps::SubpropertyEntryFor(eCSSProperty__moz_outline_radius);
     NS_FOR_CSS_FULL_CORNERS(corner) {
       int cx = NS_FULL_TO_HALF_CORNER(corner, false);
       int cy = NS_FULL_TO_HALF_CORNER(corner, true);
       const nsCSSValue& radius = *aRuleData->ValueFor(subprops[corner]);
       nsStyleCoord parentX = parentOutline->mOutlineRadius.Get(cx);
       nsStyleCoord parentY = parentOutline->mOutlineRadius.Get(cy);
       nsStyleCoord coordX, coordY;
@@ -8382,17 +8382,17 @@ nsRuleNode::ComputePositionData(void* aS
                                 nsStyleContext* aContext,
                                 nsRuleNode* aHighestNode,
                                 const RuleDetail aRuleDetail,
                                 const RuleNodeCacheConditions aConditions)
 {
   COMPUTE_START_RESET(Position, pos, parentPos)
 
   // box offsets: length, percent, calc, auto, inherit
-  static const nsCSSPropertyID offsetProps[] = {
+  static const nsCSSProperty offsetProps[] = {
     eCSSProperty_top,
     eCSSProperty_right,
     eCSSProperty_bottom,
     eCSSProperty_left
   };
   nsStyleCoord  coord;
   NS_FOR_CSS_SIDES(side) {
     nsStyleCoord parentCoord = parentPos->mOffset.Get(side);
@@ -10444,22 +10444,22 @@ nsRuleNode::HasAuthorSpecifiedRules(nsSt
   if (ruleTypeMask & NS_AUTHOR_SPECIFIED_PADDING) {
     ruleData.mValueOffsets[eStyleStruct_Padding] = paddingOffset;
   }
 
   if (ruleTypeMask & NS_AUTHOR_SPECIFIED_TEXT_SHADOW) {
     ruleData.mValueOffsets[eStyleStruct_Text] = textShadowOffset;
   }
 
-  static const nsCSSPropertyID backgroundValues[] = {
+  static const nsCSSProperty backgroundValues[] = {
     eCSSProperty_background_color,
     eCSSProperty_background_image,
   };
 
-  static const nsCSSPropertyID borderValues[] = {
+  static const nsCSSProperty borderValues[] = {
     eCSSProperty_border_top_color,
     eCSSProperty_border_top_style,
     eCSSProperty_border_top_width,
     eCSSProperty_border_right_color,
     eCSSProperty_border_right_style,
     eCSSProperty_border_right_width,
     eCSSProperty_border_bottom_color,
     eCSSProperty_border_bottom_style,
@@ -10468,36 +10468,36 @@ nsRuleNode::HasAuthorSpecifiedRules(nsSt
     eCSSProperty_border_left_style,
     eCSSProperty_border_left_width,
     eCSSProperty_border_top_left_radius,
     eCSSProperty_border_top_right_radius,
     eCSSProperty_border_bottom_right_radius,
     eCSSProperty_border_bottom_left_radius,
   };
 
-  static const nsCSSPropertyID paddingValues[] = {
+  static const nsCSSProperty paddingValues[] = {
     eCSSProperty_padding_top,
     eCSSProperty_padding_right,
     eCSSProperty_padding_bottom,
     eCSSProperty_padding_left,
   };
 
-  static const nsCSSPropertyID textShadowValues[] = {
+  static const nsCSSProperty textShadowValues[] = {
     eCSSProperty_text_shadow
   };
 
   // Number of properties we care about
   size_t nValues = 0;
 
   nsCSSValue* values[MOZ_ARRAY_LENGTH(backgroundValues) +
                      MOZ_ARRAY_LENGTH(borderValues) +
                      MOZ_ARRAY_LENGTH(paddingValues) +
                      MOZ_ARRAY_LENGTH(textShadowValues)];
 
-  nsCSSPropertyID properties[MOZ_ARRAY_LENGTH(backgroundValues) +
+  nsCSSProperty properties[MOZ_ARRAY_LENGTH(backgroundValues) +
                            MOZ_ARRAY_LENGTH(borderValues) +
                            MOZ_ARRAY_LENGTH(paddingValues) +
                            MOZ_ARRAY_LENGTH(textShadowValues)];
 
   if (ruleTypeMask & NS_AUTHOR_SPECIFIED_BACKGROUND) {
     for (uint32_t i = 0, i_end = ArrayLength(backgroundValues);
          i < i_end; ++i) {
       properties[nValues] = backgroundValues[i];
@@ -10611,30 +10611,30 @@ nsRuleNode::HasAuthorSpecifiedRules(nsSt
     }
   } while (haveExplicitUAInherit && styleContext);
 
   return false;
 }
 
 /* static */ void
 nsRuleNode::ComputePropertiesOverridingAnimation(
-                              const nsTArray<nsCSSPropertyID>& aProperties,
+                              const nsTArray<nsCSSProperty>& aProperties,
                               nsStyleContext* aStyleContext,
-                              nsCSSPropertyIDSet& aPropertiesOverridden)
+                              nsCSSPropertySet& aPropertiesOverridden)
 {
   /*
    * Set up an nsRuleData with all the structs needed for all of the
    * properties in aProperties.
    */
   uint32_t structBits = 0;
   size_t nprops = 0;
   size_t offsets[nsStyleStructID_Length];
   for (size_t propIdx = 0, propEnd = aProperties.Length();
        propIdx < propEnd; ++propIdx) {
-    nsCSSPropertyID prop = aProperties[propIdx];
+    nsCSSProperty prop = aProperties[propIdx];
     nsStyleStructID sid = nsCSSProps::kSIDTable[prop];
     uint32_t bit = nsCachedStyleData::GetBitForSID(sid);
     if (!(structBits & bit)) {
       structBits |= bit;
       offsets[sid] = nprops;
       nprops += nsCSSProps::PropertyCountInStruct(sid);
     }
   }
@@ -10685,17 +10685,17 @@ nsRuleNode::ComputePropertiesOverridingA
     }
   }
 
   /*
    * Fill in which properties were overridden.
    */
   for (size_t propIdx = 0, propEnd = aProperties.Length();
        propIdx < propEnd; ++propIdx) {
-    nsCSSPropertyID prop = aProperties[propIdx];
+    nsCSSProperty prop = aProperties[propIdx];
     if (ruleData.ValueFor(prop)->GetUnit() != eCSSUnit_Null) {
       aPropertiesOverridden.AddProperty(prop);
     }
   }
 }
 
 /* static */
 bool
--- a/layout/style/nsRuleNode.h
+++ b/layout/style/nsRuleNode.h
@@ -15,17 +15,17 @@
 #include "mozilla/LinkedList.h"
 #include "mozilla/PodOperations.h"
 #include "mozilla/RangedArray.h"
 #include "mozilla/RuleNodeCacheConditions.h"
 #include "mozilla/SheetType.h"
 #include "nsPresContext.h"
 #include "nsStyleStruct.h"
 
-class nsCSSPropertyIDSet;
+class nsCSSPropertySet;
 class nsCSSValue;
 class nsIStyleRule;
 class nsStyleContext;
 class nsStyleCoord;
 struct nsCSSRect;
 struct nsCSSValueList;
 struct nsCSSValuePairList;
 struct nsRuleData;
@@ -958,19 +958,19 @@ public:
 
   /**
    * Fill in to aPropertiesOverridden all of the properties in aProperties
    * that, for this rule node, have a declaration that is higher than the
    * animation level in the CSS Cascade.
    */
   static void
   ComputePropertiesOverridingAnimation(
-                              const nsTArray<nsCSSPropertyID>& aProperties,