--- a/layout/base/nsCSSRendering.cpp
+++ b/layout/base/nsCSSRendering.cpp
@@ -1049,17 +1049,17 @@ nsCSSRendering::PaintFocus(nsPresContext
 //----------------------------------------------------------------------
 
 /**
  * Helper for ComputeObjectAnchorPoint; parameters are the same as for
  * that function, except they're for a single coordinate / a single size
  * dimension. (so, x/width vs. y/height)
  */
 static void
-ComputeObjectAnchorCoord(const Position::PositionCoord& aCoord,
+ComputeObjectAnchorCoord(const Position::Coord& aCoord,
                          const nscoord aOriginBounds,
                          const nscoord aImageSize,
                          nscoord* aTopLeftCoord,
                          nscoord* aAnchorPointCoord)
 {
   *aAnchorPointCoord = aCoord.mLength;
   *aTopLeftCoord = aCoord.mLength;
 

--- a/layout/base/nsLayoutUtils.cpp
+++ b/layout/base/nsLayoutUtils.cpp
@@ -4146,17 +4146,17 @@ ComputeConcreteObjectSize(const nsSize& 
       MOZ_ASSERT_UNREACHABLE("Unexpected enum value for 'object-fit'");
       return aConstraintSize; // fall back to (default) 'fill' behavior
   }
 }
 
 // (Helper for HasInitialObjectFitAndPosition, to check
 // each "object-position" coord.)
 static bool
-IsCoord50Pct(const mozilla::Position::PositionCoord& aCoord)
+IsCoord50Pct(const mozilla::Position::Coord& aCoord)
 {
   return (aCoord.mLength == 0 &&
           aCoord.mHasPercent &&
           aCoord.mPercent == 0.5f);
 }
 
 // Indicates whether the given nsStylePosition has the initial values
 // for the "object-fit" and "object-position" properties.

--- a/layout/style/StyleAnimationValue.cpp
+++ b/layout/style/StyleAnimationValue.cpp
@@ -3323,17 +3323,17 @@ SetPositionValue(const Position& aPos, n
   nsCSSValue& xValue = posArray->Item(1);
   nsCSSValue& yValue = posArray->Item(3);
 
   SetCalcValue(&aPos.mXPosition, xValue);
   SetCalcValue(&aPos.mYPosition, yValue);
 }
 
 static void
-SetPositionCoordValue(const Position::PositionCoord& aPosCoord,
+SetPositionCoordValue(const Position::Coord& aPosCoord,
                       nsCSSValue& aCSSValue)
 {
   RefPtr<nsCSSValue::Array> posArray = nsCSSValue::Array::Create(2);
   aCSSValue.SetArrayValue(posArray.get(), eCSSUnit_Array);
 
   // NOTE: Array entry #0 here is intentionally left untouched, with
   // eCSSUnit_Null.  The purpose of this entry in our specified-style
   // <position-coord> representation is to store edge names.  But for values

--- a/layout/style/nsComputedDOMStyle.cpp
+++ b/layout/style/nsComputedDOMStyle.cpp
@@ -2354,17 +2354,17 @@ nsComputedDOMStyle::DoGetBackgroundOrigi
   return GetBackgroundList(&nsStyleImageLayers::Layer::mOrigin,
                            &nsStyleImageLayers::mOriginCount,
                            StyleBackground()->mImage,
                            nsCSSProps::kImageLayerOriginKTable);
 }
 
 void
 nsComputedDOMStyle::SetValueToPositionCoord(
-    const Position::PositionCoord& aCoord,
+    const Position::Coord& aCoord,
     nsROCSSPrimitiveValue* aValue)
 {
   if (!aCoord.mHasPercent) {
     MOZ_ASSERT(aCoord.mPercent == 0.0f,
                "Shouldn't have mPercent!");
     aValue->SetAppUnits(aCoord.mLength);
   } else if (aCoord.mLength == 0) {
     aValue->SetPercent(aCoord.mPercent);

--- a/layout/style/nsComputedDOMStyle.h
+++ b/layout/style/nsComputedDOMStyle.h
@@ -580,17 +580,17 @@ private:
   already_AddRefed<CSSValue> DoGetCustomProperty(const nsAString& aPropertyName);
 
   nsDOMCSSValueList* GetROCSSValueList(bool aCommaDelimited);
 
   /* Helper functions */
   void SetToRGBAColor(nsROCSSPrimitiveValue* aValue, nscolor aColor);
   void SetValueToStyleImage(const nsStyleImage& aStyleImage,
                             nsROCSSPrimitiveValue* aValue);
-  void SetValueToPositionCoord(const mozilla::Position::PositionCoord& aCoord,
+  void SetValueToPositionCoord(const mozilla::Position::Coord& aCoord,
                                nsROCSSPrimitiveValue* aValue);
   void SetValueToPosition(const mozilla::Position& aPosition,
                           nsDOMCSSValueList* aValueList);
   void SetValueToFragmentOrURL(const mozilla::FragmentOrURL* aFragmentOrURL,
                                nsROCSSPrimitiveValue* aValue);
 
   /**
    * A method to get a percentage base for a percentage value.  Returns true

--- a/layout/style/nsRuleNode.cpp
+++ b/layout/style/nsRuleNode.cpp
@@ -6732,17 +6732,17 @@ struct BackgroundItemComputer<nsCSSValue
 /* Helper function for ComputePositionValue.
  * This function computes a single PositionCoord from two nsCSSValue objects,
  * which represent an edge and an offset from that edge.
  */
 static void
 ComputePositionCoord(nsStyleContext* aStyleContext,
                      const nsCSSValue& aEdge,
                      const nsCSSValue& aOffset,
-                     Position::PositionCoord* aResult,
+                     Position::Coord* aResult,
                      RuleNodeCacheConditions& aConditions)
 {
   if (eCSSUnit_Percent == aOffset.GetUnit()) {
     aResult->mLength = 0;
     aResult->mPercent = aOffset.GetPercentValue();
     aResult->mHasPercent = true;
   } else if (aOffset.IsLengthUnit()) {
     aResult->mLength = CalcLength(aOffset, aStyleContext,
@@ -6819,17 +6819,17 @@ ComputePositionValue(nsStyleContext* aSt
                        aConditions);
 }
 
 /* Helper function to convert the -x or -y part of a CSS <position> specified
  * value into its computed-style form. */
 static void
 ComputePositionCoordValue(nsStyleContext* aStyleContext,
                           const nsCSSValue& aValue,
-                          Position::PositionCoord& aComputedValue,
+                          Position::Coord& aComputedValue,
                           RuleNodeCacheConditions& aConditions)
 {
   NS_ASSERTION(aValue.GetUnit() == eCSSUnit_Array,
                "unexpected unit for position coord value");
 
   RefPtr<nsCSSValue::Array> positionArray = aValue.GetArrayValue();
   NS_ASSERTION(positionArray->Count() == 2,
                "unexpected number of values, expecting one edge and one offset");
@@ -7016,19 +7016,19 @@ SetImageLayerList(nsStyleContext* aStyle
 // This code is duplicated because it would be annoying to make
 // SetImageLayerList generic enough to handle both cases.
 static void
 SetImageLayerPositionCoordList(
                   nsStyleContext* aStyleContext,
                   const nsCSSValue& aValue,
                   nsStyleAutoArray<nsStyleImageLayers::Layer>& aLayers,
                   const nsStyleAutoArray<nsStyleImageLayers::Layer>& aParentLayers,
-                  Position::PositionCoord
+                  Position::Coord
                       Position::* aResultLocation,
-                  Position::PositionCoord aInitialValue,
+                  Position::Coord aInitialValue,
                   uint32_t aParentItemCount,
                   uint32_t& aItemCount,
                   uint32_t& aMaxItemCount,
                   bool& aRebuild,
                   RuleNodeCacheConditions& aConditions)
 {
   switch (aValue.GetUnit()) {
   case eCSSUnit_Null:
@@ -7165,17 +7165,17 @@ FillBackgroundList(
   }
 }
 
 // The same as FillBackgroundList, but for values stored in
 // layer.mPosition.*aResultLocation instead of layer.*aResultLocation.
 static void
 FillBackgroundPositionCoordList(
     nsStyleAutoArray<nsStyleImageLayers::Layer>& aLayers,
-    Position::PositionCoord
+    Position::Coord
         Position::* aResultLocation,
     uint32_t aItemCount, uint32_t aFillCount)
 {
   NS_PRECONDITION(aFillCount <= aLayers.Length(), "unexpected array length");
   for (uint32_t sourceLayer = 0, destLayer = aItemCount;
        destLayer < aFillCount;
        ++sourceLayer, ++destLayer) {
     aLayers[destLayer].mPosition.*aResultLocation =
@@ -7263,17 +7263,17 @@ nsRuleNode::ComputeBackgroundData(void* 
                     parentBG->mImage.mLayers,
                     &nsStyleImageLayers::Layer::mOrigin,
                     uint8_t(NS_STYLE_IMAGELAYER_ORIGIN_PADDING),
                     parentBG->mImage.mOriginCount,
                     bg->mImage.mOriginCount, maxItemCount, rebuild,
                     conditions);
 
   // background-position-x/y: enum, length, percent (flags), inherit [list]
-  Position::PositionCoord initialPositionCoord;
+  Position::Coord initialPositionCoord;
   initialPositionCoord.mPercent =
     nsStyleImageLayers::GetInitialPositionForLayerType(
       nsStyleImageLayers::LayerType::Background);
   initialPositionCoord.mLength = 0;
   initialPositionCoord.mHasPercent = true;
 
   SetImageLayerPositionCoordList(
                     aContext, *aRuleData->ValueForBackgroundPositionX(),
@@ -10027,17 +10027,17 @@ nsRuleNode::ComputeSVGResetData(void* aS
                     parentSVGReset->mMask.mLayers,
                     &nsStyleImageLayers::Layer::mOrigin,
                     uint8_t(NS_STYLE_IMAGELAYER_ORIGIN_BORDER),
                     parentSVGReset->mMask.mOriginCount,
                     svgReset->mMask.mOriginCount, maxItemCount, rebuild,
                     conditions);
 
   // mask-position-x/y: enum, length, percent (flags), inherit [list]
-  Position::PositionCoord initialPositionCoord;
+  Position::Coord initialPositionCoord;
   initialPositionCoord.mPercent =
     nsStyleImageLayers::GetInitialPositionForLayerType(
       nsStyleImageLayers::LayerType::Mask);
   initialPositionCoord.mLength = 0;
   initialPositionCoord.mHasPercent = true;
 
   SetImageLayerPositionCoordList(
                     aContext, *aRuleData->ValueForMaskPositionX(),

--- a/layout/style/nsStyleStruct.h
+++ b/layout/style/nsStyleStruct.h
@@ -141,18 +141,19 @@ struct FragmentOrURL
   bool IsLocalRef() const { return mIsLocalRef; }
 
 private:
   nsCOMPtr<nsIURI> mURL;
   bool    mIsLocalRef;
 };
 
 struct Position {
-  typedef nsStyleCoord::CalcValue PositionCoord;
-  PositionCoord mXPosition, mYPosition;
+  using Coord = nsStyleCoord::CalcValue;
+
+  Coord mXPosition, mYPosition;
 
   // Initialize nothing
   Position() {}
 
   // Sets both mXPosition and mYPosition to the given percent value for the
   // initial property-value (e.g. 0.0f for "0% 0%", or 0.5f for "50% 50%")
   void SetInitialPercentValues(float aPercentVal);
 

--- a/layout/style/nsStyleUtil.cpp
+++ b/layout/style/nsStyleUtil.cpp
@@ -682,17 +682,17 @@ nsStyleUtil::IsSignificantChild(nsIConte
          (aWhitespaceIsSignificant ||
           !aChild->TextIsOnlyWhitespace());
 }
 
 // For a replaced element whose concrete object size is no larger than the
 // element's content-box, this method checks whether the given
 // "object-position" coordinate might cause overflow in its dimension.
 static bool
-ObjectPositionCoordMightCauseOverflow(const Position::PositionCoord& aCoord)
+ObjectPositionCoordMightCauseOverflow(const Position::Coord& aCoord)
 {
   // Any nonzero length in "object-position" can push us to overflow
   // (particularly if our concrete object size is exactly the same size as the
   // replaced element's content-box).
   if (aCoord.mLength != 0) {
     return true;
   }