--- a/layout/style/StyleAnimationValue.cpp
+++ b/layout/style/StyleAnimationValue.cpp
@@ -3498,18 +3498,18 @@ StyleClipBasicShapeToCSSArray(const nsSt
 {
   MOZ_ASSERT(aResult->Count() == 2,
              "Expected array to be presized for a function and the sizing-box");
 
   const nsStyleBasicShape* shape = aClipPath.GetBasicShape();
   nsCSSKeyword functionName = shape->GetShapeTypeName();
   RefPtr<nsCSSValue::Array> functionArray;
   switch (shape->GetShapeType()) {
-    case nsStyleBasicShape::Type::eCircle:
-    case nsStyleBasicShape::Type::eEllipse: {
+    case StyleBasicShapeType::Circle:
+    case StyleBasicShapeType::Ellipse: {
       const nsTArray<nsStyleCoord>& coords = shape->Coordinates();
       MOZ_ASSERT(coords.Length() == ShapeArgumentCount(functionName) - 1,
                  "Unexpected radii count");
       // The "+1" is for the center point:
       functionArray = aResult->Item(0).InitFunction(functionName,
                                                     coords.Length() + 1);
       for (size_t i = 0; i < coords.Length(); ++i) {
         if (coords[i].GetUnit() == eStyleUnit_Enumerated) {
@@ -3520,17 +3520,17 @@ StyleClipBasicShapeToCSSArray(const nsSt
           return false;
         }
       }
       // Set functionArray's last item to the circle or ellipse's center point:
       SetPositionValue(shape->GetPosition(),
                        functionArray->Item(functionArray->Count() - 1));
       break;
     }
-    case nsStyleBasicShape::Type::ePolygon: {
+    case StyleBasicShapeType::Polygon: {
       functionArray =
         aResult->Item(0).InitFunction(functionName,
                                       ShapeArgumentCount(functionName));
       functionArray->Item(1).SetIntValue(shape->GetFillRule(),
                                          eCSSUnit_Enumerated);
       nsCSSValuePairList* list = functionArray->Item(2).SetPairListValue();
       const nsTArray<nsStyleCoord>& coords = shape->Coordinates();
       MOZ_ASSERT((coords.Length() % 2) == 0);
@@ -3541,17 +3541,17 @@ StyleClipBasicShapeToCSSArray(const nsSt
         }
         if (!StyleCoordToCSSValue(coords[i], list->mXValue) ||
             !StyleCoordToCSSValue(coords[i + 1], list->mYValue)) {
           return false;
         }
       }
       break;
     }
-    case nsStyleBasicShape::Type::eInset: {
+    case StyleBasicShapeType::Inset: {
       const nsTArray<nsStyleCoord>& coords = shape->Coordinates();
       MOZ_ASSERT(coords.Length() == ShapeArgumentCount(functionName) - 1,
                  "Unexpected offset count");
       functionArray =
         aResult->Item(0).InitFunction(functionName, coords.Length() + 1);
       for (size_t i = 0; i < coords.Length(); ++i) {
         if (!StyleCoordToCSSValue(coords[i], functionArray->Item(i + 1))) {
           return false;

--- a/layout/style/nsComputedDOMStyle.cpp
+++ b/layout/style/nsComputedDOMStyle.cpp
@@ -5915,25 +5915,25 @@ nsComputedDOMStyle::BasicShapeRadiiToStr
 }
 
 already_AddRefed<CSSValue>
 nsComputedDOMStyle::CreatePrimitiveValueForBasicShape(
   const nsStyleBasicShape* aStyleBasicShape)
 {
   MOZ_ASSERT(aStyleBasicShape, "Expect a valid basic shape pointer!");
 
-  nsStyleBasicShape::Type type = aStyleBasicShape->GetShapeType();
+  StyleBasicShapeType type = aStyleBasicShape->GetShapeType();
   // Shape function name and opening parenthesis.
   nsAutoString shapeFunctionString;
   AppendASCIItoUTF16(nsCSSKeywords::GetStringValue(
                        aStyleBasicShape->GetShapeTypeName()),
                      shapeFunctionString);
   shapeFunctionString.Append('(');
   switch (type) {
-    case nsStyleBasicShape::Type::ePolygon: {
+    case StyleBasicShapeType::Polygon: {
       bool hasEvenOdd = aStyleBasicShape->GetFillRule() ==
         NS_STYLE_FILL_RULE_EVENODD;
       if (hasEvenOdd) {
         shapeFunctionString.AppendLiteral("evenodd");
       }
       for (size_t i = 0;
            i < aStyleBasicShape->Coordinates().Length(); i += 2) {
         nsAutoString coordString;
@@ -5945,21 +5945,21 @@ nsComputedDOMStyle::CreatePrimitiveValue
         shapeFunctionString.Append(coordString);
         shapeFunctionString.Append(' ');
         SetCssTextToCoord(coordString,
                           aStyleBasicShape->Coordinates()[i + 1]);
         shapeFunctionString.Append(coordString);
       }
       break;
     }
-    case nsStyleBasicShape::Type::eCircle:
-    case nsStyleBasicShape::Type::eEllipse: {
+    case StyleBasicShapeType::Circle:
+    case StyleBasicShapeType::Ellipse: {
       const nsTArray<nsStyleCoord>& radii = aStyleBasicShape->Coordinates();
       MOZ_ASSERT(radii.Length() ==
-                 (type == nsStyleBasicShape::Type::eCircle ? 1 : 2),
+                 (type == StyleBasicShapeType::Circle ? 1 : 2),
                  "wrong number of radii");
       for (size_t i = 0; i < radii.Length(); ++i) {
         nsAutoString radius;
         RefPtr<nsROCSSPrimitiveValue> value = new nsROCSSPrimitiveValue;
         bool clampNegativeCalc = true;
         SetValueToCoord(value, radii[i], clampNegativeCalc, nullptr,
                         nsCSSProps::kShapeRadiusKTable);
         value->GetCssText(radius);
@@ -5970,17 +5970,17 @@ nsComputedDOMStyle::CreatePrimitiveValue
 
       RefPtr<nsDOMCSSValueList> position = GetROCSSValueList(false);
       nsAutoString positionString;
       SetValueToPosition(aStyleBasicShape->GetPosition(), position);
       position->GetCssText(positionString);
       shapeFunctionString.Append(positionString);
       break;
     }
-    case nsStyleBasicShape::Type::eInset: {
+    case StyleBasicShapeType::Inset: {
       BoxValuesToString(shapeFunctionString, aStyleBasicShape->Coordinates());
       if (aStyleBasicShape->HasRadius()) {
         shapeFunctionString.AppendLiteral(" round ");
         nsAutoString radiiString;
         BasicShapeRadiiToString(radiiString, aStyleBasicShape->GetRadius());
         shapeFunctionString.Append(radiiString);
       }
       break;

--- a/layout/style/nsRuleNode.cpp
+++ b/layout/style/nsRuleNode.cpp
@@ -9590,17 +9590,17 @@ GetStyleBasicShapeFromCSSValue(const nsC
   RefPtr<nsStyleBasicShape> basicShape;
 
   nsCSSValue::Array* shapeFunction = aValue.GetArrayValue();
   nsCSSKeyword functionName =
     (nsCSSKeyword)shapeFunction->Item(0).GetIntValue();
 
   if (functionName == eCSSKeyword_polygon) {
     MOZ_ASSERT(!basicShape, "did not expect value");
-    basicShape = new nsStyleBasicShape(nsStyleBasicShape::ePolygon);
+    basicShape = new nsStyleBasicShape(StyleBasicShapeType::Polygon);
     MOZ_ASSERT(shapeFunction->Count() > 1,
                "polygon has wrong number of arguments");
     size_t j = 1;
     if (shapeFunction->Item(j).GetUnit() == eCSSUnit_Enumerated) {
       basicShape->SetFillRule(shapeFunction->Item(j).GetIntValue());
       ++j;
     }
     const int32_t mask = SETCOORD_PERCENT | SETCOORD_LENGTH |
@@ -9621,27 +9621,27 @@ GetStyleBasicShapeFromCSSValue(const nsC
                                               aStyleContext, aPresContext,
                                               aConditions);
       coordinates.AppendElement(yCoord);
       MOZ_ASSERT(didSetCoordY, "unexpected y coordinate unit");
       curPair = curPair->mNext;
     }
   } else if (functionName == eCSSKeyword_circle ||
              functionName == eCSSKeyword_ellipse) {
-    nsStyleBasicShape::Type type = functionName == eCSSKeyword_circle ?
-      nsStyleBasicShape::eCircle :
-      nsStyleBasicShape::eEllipse;
+    StyleBasicShapeType type = functionName == eCSSKeyword_circle ?
+      StyleBasicShapeType::Circle :
+      StyleBasicShapeType::Ellipse;
     MOZ_ASSERT(!basicShape, "did not expect value");
     basicShape = new nsStyleBasicShape(type);
     const int32_t mask = SETCOORD_PERCENT | SETCOORD_LENGTH |
       SETCOORD_STORE_CALC | SETCOORD_ENUMERATED;
-    size_t count = type == nsStyleBasicShape::eCircle ? 2 : 3;
+    size_t count = type == StyleBasicShapeType::Circle ? 2 : 3;
     MOZ_ASSERT(shapeFunction->Count() == count + 1,
                "unexpected arguments count");
-    MOZ_ASSERT(type == nsStyleBasicShape::eCircle ||
+    MOZ_ASSERT(type == StyleBasicShapeType::Circle ||
                (shapeFunction->Item(1).GetUnit() == eCSSUnit_Null) ==
                (shapeFunction->Item(2).GetUnit() == eCSSUnit_Null),
                "ellipse should have two radii or none");
     for (size_t j = 1; j < count; ++j) {
       const nsCSSValue& val = shapeFunction->Item(j);
       nsStyleCoord radius;
       if (val.GetUnit() != eCSSUnit_Null) {
         DebugOnly<bool> didSetRadius = SetCoord(val, radius,
@@ -9661,17 +9661,17 @@ GetStyleBasicShapeFromCSSValue(const nsC
                            basicShape->GetPosition(),
                            aConditions);
     } else {
       MOZ_ASSERT(positionVal.GetUnit() == eCSSUnit_Null,
                  "expected no value");
     }
   } else if (functionName == eCSSKeyword_inset) {
     MOZ_ASSERT(!basicShape, "did not expect value");
-    basicShape = new nsStyleBasicShape(nsStyleBasicShape::eInset);
+    basicShape = new nsStyleBasicShape(StyleBasicShapeType::Inset);
     MOZ_ASSERT(shapeFunction->Count() == 6,
                "inset function has wrong number of arguments");
     MOZ_ASSERT(shapeFunction->Item(1).GetUnit() != eCSSUnit_Null,
                "no shape arguments defined");
     const int32_t mask = SETCOORD_PERCENT | SETCOORD_LENGTH |
       SETCOORD_STORE_CALC;
     nsTArray<nsStyleCoord>& coords = basicShape->Coordinates();
     for (size_t j = 1; j <= 4; ++j) {

--- a/layout/style/nsStyleConsts.h
+++ b/layout/style/nsStyleConsts.h
@@ -49,18 +49,18 @@ static inline css::Side operator++(css::
 #define NS_FULL_TO_HALF_CORNER(var_, vert_) ((var_)*2 + !!(vert_))
 
 #define NS_SIDE_IS_VERTICAL(side_) ((side_) % 2)
 #define NS_SIDE_TO_FULL_CORNER(side_, second_) \
   (((side_) + !!(second_)) % 4)
 #define NS_SIDE_TO_HALF_CORNER(side_, second_, parallel_) \
   ((((side_) + !!(second_))*2 + ((side_) + !(parallel_))%2) % 8)
 
-// Basic Shapes (currently unused)
-enum class StyleBasicShape : uint8_t{
+// Basic shapes
+enum class StyleBasicShapeType : uint8_t {
   Polygon,
   Circle,
   Ellipse,
   Inset,
 };
 
 // box-sizing
 enum class StyleBoxSizing : uint8_t {

--- a/layout/style/nsStyleStruct.cpp
+++ b/layout/style/nsStyleStruct.cpp
@@ -1087,23 +1087,23 @@ nsStyleSVG::CalcDifference(const nsStyle
 
 // --------------------
 // nsStyleBasicShape
 
 nsCSSKeyword
 nsStyleBasicShape::GetShapeTypeName() const
 {
   switch (mType) {
-    case nsStyleBasicShape::Type::ePolygon:
+    case StyleBasicShapeType::Polygon:
       return eCSSKeyword_polygon;
-    case nsStyleBasicShape::Type::eCircle:
+    case StyleBasicShapeType::Circle:
       return eCSSKeyword_circle;
-    case nsStyleBasicShape::Type::eEllipse:
+    case StyleBasicShapeType::Ellipse:
       return eCSSKeyword_ellipse;
-    case nsStyleBasicShape::Type::eInset:
+    case StyleBasicShapeType::Inset:
       return eCSSKeyword_inset;
   }
   NS_NOTREACHED("unexpected type");
   return eCSSKeyword_UNKNOWN;
 }
 
 // --------------------
 // nsStyleClipPath

--- a/layout/style/nsStyleStruct.h
+++ b/layout/style/nsStyleStruct.h
@@ -3436,69 +3436,64 @@ private:
   uint8_t          mContextFlags;     // [inherited]
 };
 
 namespace mozilla {
 
 class nsStyleBasicShape final
 {
 public:
-  enum Type {
-    eInset,
-    eCircle,
-    eEllipse,
-    ePolygon
-  };
-
-  explicit nsStyleBasicShape(Type type)
+  explicit nsStyleBasicShape(StyleBasicShapeType type)
     : mType(type),
       mFillRule(NS_STYLE_FILL_RULE_NONZERO)
   {
     mPosition.SetInitialPercentValues(0.5f);
   }
 
-  Type GetShapeType() const { return mType; }
+  StyleBasicShapeType GetShapeType() const { return mType; }
   nsCSSKeyword GetShapeTypeName() const;
 
   int32_t GetFillRule() const { return mFillRule; }
   void SetFillRule(int32_t aFillRule)
   {
-    NS_ASSERTION(mType == ePolygon, "expected polygon");
+    MOZ_ASSERT(mType == StyleBasicShapeType::Polygon, "expected polygon");
     mFillRule = aFillRule;
   }
 
   typedef nsStyleImageLayers::Position Position;
   Position& GetPosition() {
-    NS_ASSERTION(mType == eCircle || mType == eEllipse,
-                 "expected circle or ellipse");
+    MOZ_ASSERT(mType == StyleBasicShapeType::Circle ||
+               mType == StyleBasicShapeType::Ellipse,
+               "expected circle or ellipse");
     return mPosition;
   }
   const Position& GetPosition() const {
-    NS_ASSERTION(mType == eCircle || mType == eEllipse,
-                 "expected circle or ellipse");
+    MOZ_ASSERT(mType == StyleBasicShapeType::Circle ||
+               mType == StyleBasicShapeType::Ellipse,
+               "expected circle or ellipse");
     return mPosition;
   }
 
   bool HasRadius() const {
-    NS_ASSERTION(mType == eInset, "expected inset");
+    MOZ_ASSERT(mType == StyleBasicShapeType::Inset, "expected inset");
     nsStyleCoord zero;
     zero.SetCoordValue(0);
     NS_FOR_CSS_HALF_CORNERS(corner) {
       if (mRadius.Get(corner) != zero) {
         return true;
       }
     }
     return false;
   }
   nsStyleCorners& GetRadius() {
-    NS_ASSERTION(mType == eInset, "expected inset");
+    MOZ_ASSERT(mType == StyleBasicShapeType::Inset, "expected inset");
     return mRadius;
   }
   const nsStyleCorners& GetRadius() const {
-    NS_ASSERTION(mType == eInset, "expected inset");
+    MOZ_ASSERT(mType == StyleBasicShapeType::Inset, "expected inset");
     return mRadius;
   }
 
   // mCoordinates has coordinates for polygon or radii for
   // ellipse and circle.
   nsTArray<nsStyleCoord>& Coordinates()
   {
     return mCoordinates;
@@ -3521,17 +3516,17 @@ public:
     return !(*this == aOther);
   }
 
   NS_INLINE_DECL_REFCOUNTING(nsStyleBasicShape);
 
 private:
   ~nsStyleBasicShape() {}
 
-  Type mType;
+  StyleBasicShapeType mType;
   int32_t mFillRule;
 
   // mCoordinates has coordinates for polygon or radii for
   // ellipse and circle.
   nsTArray<nsStyleCoord> mCoordinates;
   Position mPosition;
   nsStyleCorners mRadius;
 };

--- a/layout/svg/nsCSSClipPathInstance.cpp
+++ b/layout/svg/nsCSSClipPathInstance.cpp
@@ -89,23 +89,23 @@ nsCSSClipPathInstance::CreateClipPath(Dr
   }
 
   nscoord appUnitsPerDevPixel =
     mTargetFrame->PresContext()->AppUnitsPerDevPixel();
   r = ToAppUnits(r.ToNearestPixels(appUnitsPerDevPixel), appUnitsPerDevPixel);
 
   nsStyleBasicShape* basicShape = mClipPathStyle.GetBasicShape();
   switch (basicShape->GetShapeType()) {
-    case nsStyleBasicShape::Type::eCircle:
+    case StyleBasicShapeType::Circle:
       return CreateClipPathCircle(aDrawTarget, r);
-    case nsStyleBasicShape::Type::eEllipse:
+    case StyleBasicShapeType::Ellipse:
       return CreateClipPathEllipse(aDrawTarget, r);
-    case nsStyleBasicShape::Type::ePolygon:
+    case StyleBasicShapeType::Polygon:
       return CreateClipPathPolygon(aDrawTarget, r);
-    case nsStyleBasicShape::Type::eInset:
+    case StyleBasicShapeType::Inset:
       // XXXkrit support all basic shapes
       break;
     default:
       MOZ_MAKE_COMPILER_ASSUME_IS_UNREACHABLE("Unexpected shape type");
   }
   // Return an empty Path:
   RefPtr<PathBuilder> builder = aDrawTarget->CreatePathBuilder();
   return builder->Finish();