--- a/layout/generic/nsFloatManager.cpp
+++ b/layout/generic/nsFloatManager.cpp
@@ -604,17 +604,17 @@ nsFloatManager::FloatInfo::FloatInfo(nsI
                                      WritingMode aWM,
                                      const nsSize& aContainerSize)
   : mFrame(aFrame)
   , mRect(ShapeInfo::ConvertToFloatLogical(aMarginRect, aWM, aContainerSize) +
           nsPoint(aLineLeft, aBlockStart))
 {
   MOZ_COUNT_CTOR(nsFloatManager::FloatInfo);
 
-  const StyleShapeOutside& shapeOutside = mFrame->StyleDisplay()->mShapeOutside;
+  const StyleShapeSource& shapeOutside = mFrame->StyleDisplay()->mShapeOutside;
 
   if (shapeOutside.GetType() == StyleShapeSourceType::None) {
     return;
   }
 
   if (shapeOutside.GetType() == StyleShapeSourceType::URL) {
     // Bug 1265343: Implement 'shape-image-threshold'. Early return
     // here because shape-outside with url() value doesn't have a
@@ -759,37 +759,38 @@ nsFloatManager::FloatInfo::IsEmpty(Shape
   return mShapeInfo->IsEmpty();
 }
 
 /////////////////////////////////////////////////////////////////////////////
 // ShapeInfo
 
 /* static */ LogicalRect
 nsFloatManager::ShapeInfo::ComputeShapeBoxRect(
-  const StyleShapeOutside& aShapeOutside,
+  const StyleShapeSource& aShapeOutside,
   nsIFrame* const aFrame,
   const mozilla::LogicalRect& aMarginRect,
   mozilla::WritingMode aWM)
 {
   LogicalRect rect = aMarginRect;
 
   switch (aShapeOutside.GetReferenceBox()) {
-    case StyleShapeOutsideShapeBox::Content:
+    case StyleGeometryBox::Content:
       rect.Deflate(aWM, aFrame->GetLogicalUsedPadding(aWM));
       MOZ_FALLTHROUGH;
-    case StyleShapeOutsideShapeBox::Padding:
+    case StyleGeometryBox::Padding:
       rect.Deflate(aWM, aFrame->GetLogicalUsedBorder(aWM));
       MOZ_FALLTHROUGH;
-    case StyleShapeOutsideShapeBox::Border:
+    case StyleGeometryBox::Border:
       rect.Deflate(aWM, aFrame->GetLogicalUsedMargin(aWM));
       break;
-    case StyleShapeOutsideShapeBox::Margin:
+    case StyleGeometryBox::Margin:
       // Do nothing. rect is already a margin rect.
       break;
-    case StyleShapeOutsideShapeBox::NoBox:
+    case StyleGeometryBox::NoBox:
+    default:
       MOZ_ASSERT(aShapeOutside.GetType() != StyleShapeSourceType::Box,
                  "Box source type must have <shape-box> specified!");
       break;
   }
 
   return rect;
 }
 

--- a/layout/generic/nsFloatManager.h
+++ b/layout/generic/nsFloatManager.h
@@ -357,17 +357,17 @@ private:
     virtual nscoord BStart() const = 0;
     virtual nscoord BEnd() const = 0;
     virtual bool IsEmpty() const = 0;
 
     // Translate the current origin by the specified offsets.
     virtual void Translate(nscoord aLineLeft, nscoord aBlockStart) = 0;
 
     static mozilla::LogicalRect ComputeShapeBoxRect(
-      const mozilla::StyleShapeOutside& aShapeOutside,
+      const mozilla::StyleShapeSource& aShapeOutside,
       nsIFrame* const aFrame,
       const mozilla::LogicalRect& aMarginRect,
       mozilla::WritingMode aWM);
 
     // Convert the LogicalRect to the special logical coordinate space used
     // in float manager.
     static nsRect ConvertToFloatLogical(const mozilla::LogicalRect& aRect,
                                         mozilla::WritingMode aWM,

--- a/layout/generic/nsFrame.cpp
+++ b/layout/generic/nsFrame.cpp
@@ -1431,26 +1431,29 @@ nsIFrame::GetContentBoxBorderRadii(nscoo
   }
   return false;
 }
 
 bool
 nsIFrame::GetShapeBoxBorderRadii(nscoord aRadii[8]) const
 {
   switch (StyleDisplay()->mShapeOutside.GetReferenceBox()) {
-    case StyleShapeOutsideShapeBox::NoBox:
+    case StyleGeometryBox::NoBox:
       return false;
-    case StyleShapeOutsideShapeBox::Content:
+    case StyleGeometryBox::Content:
       return GetContentBoxBorderRadii(aRadii);
-    case StyleShapeOutsideShapeBox::Padding:
+    case StyleGeometryBox::Padding:
       return GetPaddingBoxBorderRadii(aRadii);
-    case StyleShapeOutsideShapeBox::Border:
+    case StyleGeometryBox::Border:
       return GetBorderRadii(aRadii);
-    case StyleShapeOutsideShapeBox::Margin:
+    case StyleGeometryBox::Margin:
       return GetMarginBoxBorderRadii(aRadii);
+    default:
+      MOZ_ASSERT_UNREACHABLE("Unexpected box value");
+      return false;
   }
   return false;
 }
 
 nsStyleContext*
 nsFrame::GetAdditionalStyleContext(int32_t aIndex) const
 {
   NS_PRECONDITION(aIndex >= 0, "invalid index number");

--- a/layout/style/ServoBindings.cpp
+++ b/layout/style/ServoBindings.cpp
@@ -1014,32 +1014,32 @@ Gecko_SetStyleCoordCalcValue(nsStyleUnit
   calcRef->mPercent = aCalc.mPercent;
   calcRef->mHasPercent = aCalc.mHasPercent;
   *aUnit = nsStyleUnit::eStyleUnit_Calc;
   aValue->mPointer = calcRef;
   calcRef->AddRef();
 }
 
 void
-Gecko_CopyClipPathValueFrom(mozilla::StyleClipPath* aDst, const mozilla::StyleClipPath* aSrc)
+Gecko_CopyClipPathValueFrom(mozilla::StyleShapeSource* aDst, const mozilla::StyleShapeSource* aSrc)
 {
   MOZ_ASSERT(aDst);
   MOZ_ASSERT(aSrc);
 
   *aDst = *aSrc;
 }
 
 void
-Gecko_DestroyClipPath(mozilla::StyleClipPath* aClip)
+Gecko_DestroyClipPath(mozilla::StyleShapeSource* aClip)
 {
-  aClip->~StyleClipPath();
+  aClip->~StyleShapeSource();
 }
 
 void
-Gecko_StyleClipPath_SetURLValue(mozilla::StyleClipPath* aClip, ServoBundledURI aURI)
+Gecko_StyleClipPath_SetURLValue(mozilla::StyleShapeSource* aClip, ServoBundledURI aURI)
 {
   RefPtr<css::URLValue> url = aURI.IntoCssUrl();
   aClip->SetURL(url.get());
 }
 
 mozilla::StyleBasicShape*
 Gecko_NewBasicShape(mozilla::StyleBasicShapeType aType)
 {

--- a/layout/style/ServoBindings.h
+++ b/layout/style/ServoBindings.h
@@ -280,21 +280,21 @@ mozilla::Keyframe* Gecko_AnimationAppend
                                                  const nsTimingFunction* timingFunction);
 
 // Clean up pointer-based coordinates
 void Gecko_ResetStyleCoord(nsStyleUnit* unit, nsStyleUnion* value);
 
 // Set an nsStyleCoord to a computed `calc()` value
 void Gecko_SetStyleCoordCalcValue(nsStyleUnit* unit, nsStyleUnion* value, nsStyleCoord::CalcValue calc);
 
-void Gecko_CopyClipPathValueFrom(mozilla::StyleClipPath* dst, const mozilla::StyleClipPath* src);
+void Gecko_CopyClipPathValueFrom(mozilla::StyleShapeSource* dst, const mozilla::StyleShapeSource* src);
 
-void Gecko_DestroyClipPath(mozilla::StyleClipPath* clip);
+void Gecko_DestroyClipPath(mozilla::StyleShapeSource* clip);
 mozilla::StyleBasicShape* Gecko_NewBasicShape(mozilla::StyleBasicShapeType type);
-void Gecko_StyleClipPath_SetURLValue(mozilla::StyleClipPath* clip, ServoBundledURI uri);
+void Gecko_StyleClipPath_SetURLValue(mozilla::StyleShapeSource* clip, ServoBundledURI uri);
 
 void Gecko_ResetFilters(nsStyleEffects* effects, size_t new_len);
 void Gecko_CopyFiltersFrom(nsStyleEffects* aSrc, nsStyleEffects* aDest);
 void Gecko_nsStyleFilter_SetURLValue(nsStyleFilter* effects, ServoBundledURI uri);
 
 void Gecko_nsStyleSVGPaint_CopyFrom(nsStyleSVGPaint* dest, const nsStyleSVGPaint* src);
 void Gecko_nsStyleSVGPaint_SetURLValue(nsStyleSVGPaint* paint, ServoBundledURI uri);
 void Gecko_nsStyleSVGPaint_Reset(nsStyleSVGPaint* paint);

--- a/layout/style/StyleAnimationValue.cpp
+++ b/layout/style/StyleAnimationValue.cpp
@@ -4097,17 +4097,17 @@ ExtractImageLayerSizePairList(const nsSt
         break;
     }
   }
 
   aComputedValue.SetAndAdoptCSSValuePairListValue(result.forget());
 }
 
 static bool
-StyleClipBasicShapeToCSSArray(const StyleClipPath& aClipPath,
+StyleClipBasicShapeToCSSArray(const StyleShapeSource& aClipPath,
                               nsCSSValue::Array* aResult)
 {
   MOZ_ASSERT(aResult->Count() == 2,
              "Expected array to be presized for a function and the sizing-box");
 
   const StyleBasicShape* shape = aClipPath.GetBasicShape();
   nsCSSKeyword functionName = shape->GetShapeTypeName();
   RefPtr<nsCSSValue::Array> functionArray;
@@ -4469,17 +4469,17 @@ StyleAnimationValue::ExtractComputedValu
           ExtractImageLayerSizePairList(layers, aComputedValue);
           break;
         }
 #endif
 
         case eCSSProperty_clip_path: {
           const nsStyleSVGReset* svgReset =
             static_cast<const nsStyleSVGReset*>(styleStruct);
-          const StyleClipPath& clipPath = svgReset->mClipPath;
+          const StyleShapeSource& clipPath = svgReset->mClipPath;
           const StyleShapeSourceType type = clipPath.GetType();
 
           if (type == StyleShapeSourceType::URL) {
             auto result = MakeUnique<nsCSSValue>();
             result->SetURLValue(clipPath.GetURL());
             aComputedValue.SetAndAdoptCSSValueValue(result.release(), eUnit_URL);
           } else if (type == StyleShapeSourceType::Box) {
             aComputedValue.SetEnumValue(clipPath.GetReferenceBox());

--- a/layout/style/nsComputedDOMStyle.cpp
+++ b/layout/style/nsComputedDOMStyle.cpp
@@ -6212,20 +6212,19 @@ nsComputedDOMStyle::CreatePrimitiveValue
 
   RefPtr<nsROCSSPrimitiveValue> val = new nsROCSSPrimitiveValue;
   val->SetIdent(nsCSSProps::ValueToKeywordEnum(aReferenceBox, aBoxKeywordTable));
   valueList->AppendCSSValue(val.forget());
 
   return valueList.forget();
 }
 
-template<typename ReferenceBox>
 already_AddRefed<CSSValue>
 nsComputedDOMStyle::GetShapeSource(
-  const StyleShapeSource<ReferenceBox>& aShapeSource,
+  const StyleShapeSource& aShapeSource,
   const KTableEntry aBoxKeywordTable[])
 {
   switch (aShapeSource.GetType()) {
     case StyleShapeSourceType::Shape:
       return CreatePrimitiveValueForShapeSource(aShapeSource.GetBasicShape(),
                                                 aShapeSource.GetReferenceBox(),
                                                 aBoxKeywordTable);
     case StyleShapeSourceType::Box:

--- a/layout/style/nsComputedDOMStyle.h
+++ b/layout/style/nsComputedDOMStyle.h
@@ -656,19 +656,18 @@ private:
   bool GetFrameBorderRectWidth(nscoord& aWidth);
   bool GetFrameBorderRectHeight(nscoord& aHeight);
 
   /* Helper functions for computing the filter property style. */
   void SetCssTextToCoord(nsAString& aCssText, const nsStyleCoord& aCoord);
   already_AddRefed<CSSValue> CreatePrimitiveValueForStyleFilter(
     const nsStyleFilter& aStyleFilter);
 
-  template<typename ReferenceBox>
   already_AddRefed<CSSValue>
-  GetShapeSource(const mozilla::StyleShapeSource<ReferenceBox>& aShapeSource,
+  GetShapeSource(const mozilla::StyleShapeSource& aShapeSource,
                  const KTableEntry aBoxKeywordTable[]);
 
   template<typename ReferenceBox>
   already_AddRefed<CSSValue>
   CreatePrimitiveValueForShapeSource(
     const mozilla::StyleBasicShape* aStyleBasicShape,
     ReferenceBox aReferenceBox,
     const KTableEntry aBoxKeywordTable[]);

--- a/layout/style/nsRuleNode.cpp
+++ b/layout/style/nsRuleNode.cpp
@@ -136,19 +136,18 @@ CreateStyleImageRequest(nsPresContext* a
     ? aPresContext->Document()->ImageTracker()
     : nullptr;
   RefPtr<imgRequestProxy> proxy = CreateImageRequest(aPresContext, aValue);
   RefPtr<nsStyleImageRequest> request =
     new nsStyleImageRequest(aModeFlags, proxy, imageValue, imageTracker);
   return request.forget();
 }
 
-template<typename ReferenceBox>
 static void
-SetStyleShapeSourceToCSSValue(StyleShapeSource<ReferenceBox>* aShapeSource,
+SetStyleShapeSourceToCSSValue(StyleShapeSource* aShapeSource,
                               const nsCSSValue* aValue,
                               nsStyleContext* aStyleContext,
                               nsPresContext* aPresContext,
                               RuleNodeCacheConditions& aConditions);
 
 /* Helper function to convert a CSS <position> specified value into its
  * computed-style form. */
 static void
@@ -6613,29 +6612,29 @@ nsRuleNode::ComputeDisplayData(void* aSt
   // shape-outside: none | [ <basic-shape> || <shape-box> ] | <image>
   const nsCSSValue* shapeOutsideValue = aRuleData->ValueForShapeOutside();
   switch (shapeOutsideValue->GetUnit()) {
     case eCSSUnit_Null:
       break;
     case eCSSUnit_None:
     case eCSSUnit_Initial:
     case eCSSUnit_Unset:
-      display->mShapeOutside = StyleShapeOutside();
+      display->mShapeOutside = StyleShapeSource();
       break;
     case eCSSUnit_Inherit:
       conditions.SetUncacheable();
       display->mShapeOutside = parentDisplay->mShapeOutside;
       break;
     case eCSSUnit_URL: {
-      display->mShapeOutside = StyleShapeOutside();
+      display->mShapeOutside = StyleShapeSource();
       display->mShapeOutside.SetURL(shapeOutsideValue->GetURLStructValue());
       break;
     }
     case eCSSUnit_Array: {
-      display->mShapeOutside = StyleShapeOutside();
+      display->mShapeOutside = StyleShapeSource();
       SetStyleShapeSourceToCSSValue(&display->mShapeOutside, shapeOutsideValue,
                                     aContext, mPresContext, conditions);
       break;
     }
     default:
       MOZ_ASSERT_UNREACHABLE("Unrecognized shape-outside unit!");
   }
 
@@ -9836,39 +9835,38 @@ GetStyleBasicShapeFromCSSValue(const nsC
     }
   } else {
     NS_NOTREACHED("unexpected basic shape function");
   }
 
   return basicShape.forget();
 }
 
-template<typename ReferenceBox>
 static void
 SetStyleShapeSourceToCSSValue(
-  StyleShapeSource<ReferenceBox>* aShapeSource,
+  StyleShapeSource* aShapeSource,
   const nsCSSValue* aValue,
   nsStyleContext* aStyleContext,
   nsPresContext* aPresContext,
   RuleNodeCacheConditions& aConditions)
 {
   MOZ_ASSERT(aValue->GetUnit() == eCSSUnit_Array,
              "expected a basic shape or reference box");
 
   const nsCSSValue::Array* array = aValue->GetArrayValue();
   MOZ_ASSERT(array->Count() == 1 || array->Count() == 2,
              "Expect one or both of a shape function and a reference box");
 
-  ReferenceBox referenceBox = ReferenceBox::NoBox;
+  StyleGeometryBox referenceBox = StyleGeometryBox::NoBox;
   RefPtr<StyleBasicShape> basicShape;
 
   for (size_t i = 0; i < array->Count(); ++i) {
     const nsCSSValue& item = array->Item(i);
     if (item.GetUnit() == eCSSUnit_Enumerated) {
-      referenceBox = static_cast<ReferenceBox>(item.GetIntValue());
+      referenceBox = static_cast<StyleGeometryBox>(item.GetIntValue());
     } else if (item.GetUnit() == eCSSUnit_Function) {
       basicShape = GetStyleBasicShapeFromCSSValue(item, aStyleContext,
                                                   aPresContext, aConditions);
     } else {
       MOZ_ASSERT_UNREACHABLE("Unexpected unit!");
       return;
     }
   }
@@ -9983,29 +9981,29 @@ nsRuleNode::ComputeSVGResetData(void* aS
   // clip-path: url, <basic-shape> || <geometry-box>, none, inherit
   const nsCSSValue* clipPathValue = aRuleData->ValueForClipPath();
   switch (clipPathValue->GetUnit()) {
     case eCSSUnit_Null:
       break;
     case eCSSUnit_None:
     case eCSSUnit_Initial:
     case eCSSUnit_Unset:
-      svgReset->mClipPath = StyleClipPath();
+      svgReset->mClipPath = StyleShapeSource();
       break;
     case eCSSUnit_Inherit:
       conditions.SetUncacheable();
       svgReset->mClipPath = parentSVGReset->mClipPath;
       break;
     case eCSSUnit_URL: {
-      svgReset->mClipPath = StyleClipPath();
+      svgReset->mClipPath = StyleShapeSource();
       svgReset->mClipPath.SetURL(clipPathValue->GetURLStructValue());
       break;
     }
     case eCSSUnit_Array: {
-      svgReset->mClipPath = StyleClipPath();
+      svgReset->mClipPath = StyleShapeSource();
       SetStyleShapeSourceToCSSValue(&svgReset->mClipPath, clipPathValue, aContext,
                                     mPresContext, conditions);
       break;
     }
     default:
       NS_NOTREACHED("unexpected unit");
   }
 

--- a/layout/style/nsStyleConsts.h
+++ b/layout/style/nsStyleConsts.h
@@ -79,18 +79,18 @@ enum class StyleClear : uint8_t {
   InlineEnd,
   Both,
   // StyleClear::Line can be added to one of the other values in layout
   // so it needs to use a bit value that none of the other values can have.
   Line = 8,
   Max = 13  // Max = (Both | Line)
 };
 
-// Define geometry box for clip-path's reference-box, background-clip,
-// background-origin, mask-clip and mask-origin.
+// Define geometry box for clip-path's reference-box, shape-outside's shape
+// box, background-clip, background-origin, mask-clip and mask-origin.
 enum class StyleGeometryBox : uint8_t {
   Content,
   Padding,
   Border,
   Margin,  // XXX Bug 1260094 comment 9.
            // Although margin-box is required by mask-origin and mask-clip, we
            // do not implement that due to lack of support in other browsers.
            // clip-path reference-box only.

--- a/layout/style/nsStyleStruct.h
+++ b/layout/style/nsStyleStruct.h
@@ -2635,17 +2635,16 @@ private:
   // (top, right, bottom, left) for inset
   nsTArray<nsStyleCoord> mCoordinates;
   // position of center for ellipse or circle
   Position mPosition;
   // corner radii for inset (0 if not set)
   nsStyleCorners mRadius;
 };
 
-template<typename ReferenceBox>
 struct StyleShapeSource
 {
   StyleShapeSource()
     : mURL(nullptr)
   {}
 
   StyleShapeSource(const StyleShapeSource& aSource)
     : StyleShapeSource()
@@ -2673,17 +2672,17 @@ struct StyleShapeSource
     if (aOther.mType == StyleShapeSourceType::URL) {
       SetURL(aOther.mURL);
     } else if (aOther.mType == StyleShapeSourceType::Shape) {
       SetBasicShape(aOther.mBasicShape, aOther.mReferenceBox);
     } else if (aOther.mType == StyleShapeSourceType::Box) {
       SetReferenceBox(aOther.mReferenceBox);
     } else {
       ReleaseRef();
-      mReferenceBox = ReferenceBox::NoBox;
+      mReferenceBox = StyleGeometryBox::NoBox;
       mType = StyleShapeSourceType::None;
     }
     return *this;
   }
 
   bool operator==(const StyleShapeSource& aOther) const
   {
     if (mType != aOther.mType) {
@@ -2730,35 +2729,35 @@ struct StyleShapeSource
 
   StyleBasicShape* GetBasicShape() const
   {
     MOZ_ASSERT(mType == StyleShapeSourceType::Shape, "Wrong shape source type!");
     return mBasicShape;
   }
 
   void SetBasicShape(StyleBasicShape* aBasicShape,
-                     ReferenceBox aReferenceBox)
+                     StyleGeometryBox aReferenceBox)
   {
     NS_ASSERTION(aBasicShape, "expected pointer");
     ReleaseRef();
     mBasicShape = aBasicShape;
     mBasicShape->AddRef();
     mReferenceBox = aReferenceBox;
     mType = StyleShapeSourceType::Shape;
   }
 
-  ReferenceBox GetReferenceBox() const
+  StyleGeometryBox GetReferenceBox() const
   {
     MOZ_ASSERT(mType == StyleShapeSourceType::Box ||
                mType == StyleShapeSourceType::Shape,
                "Wrong shape source type!");
     return mReferenceBox;
   }
 
-  void SetReferenceBox(ReferenceBox aReferenceBox)
+  void SetReferenceBox(StyleGeometryBox aReferenceBox)
   {
     ReleaseRef();
     mReferenceBox = aReferenceBox;
     mType = StyleShapeSourceType::Box;
   }
 
 private:
   void ReleaseRef()
@@ -2777,22 +2776,19 @@ private:
 
   void* operator new(size_t) = delete;
 
   union {
     StyleBasicShape* mBasicShape;
     css::URLValue* mURL;
   };
   StyleShapeSourceType mType = StyleShapeSourceType::None;
-  ReferenceBox mReferenceBox = ReferenceBox::NoBox;
+  StyleGeometryBox mReferenceBox = StyleGeometryBox::NoBox;
 };
 
-using StyleClipPath = StyleShapeSource<StyleGeometryBox>;
-using StyleShapeOutside = StyleShapeSource<StyleShapeOutsideShapeBox>;
-
 } // namespace mozilla
 
 struct MOZ_NEEDS_MEMMOVABLE_MEMBERS nsStyleDisplay
 {
   explicit nsStyleDisplay(const nsPresContext* aContext);
   nsStyleDisplay(const nsStyleDisplay& aOther);
   ~nsStyleDisplay();
 
@@ -2905,17 +2901,17 @@ struct MOZ_NEEDS_MEMMOVABLE_MEMBERS nsSt
            mAnimationDurationCount,
            mAnimationDelayCount,
            mAnimationNameCount,
            mAnimationDirectionCount,
            mAnimationFillModeCount,
            mAnimationPlayStateCount,
            mAnimationIterationCountCount;
 
-  mozilla::StyleShapeOutside mShapeOutside; // [reset]
+  mozilla::StyleShapeSource mShapeOutside; // [reset]
 
   bool IsBlockInsideStyle() const {
     return mozilla::StyleDisplay::Block == mDisplay ||
            mozilla::StyleDisplay::ListItem == mDisplay ||
            mozilla::StyleDisplay::InlineBlock == mDisplay ||
            mozilla::StyleDisplay::TableCaption == mDisplay ||
            mozilla::StyleDisplay::FlowRoot == mDisplay;
     // Should TABLE_CELL be included here?  They have
@@ -3885,17 +3881,17 @@ struct MOZ_NEEDS_MEMMOVABLE_MEMBERS nsSt
     return mClipPath.GetType() != mozilla::StyleShapeSourceType::None;
   }
 
   bool HasNonScalingStroke() const {
     return mVectorEffect == NS_STYLE_VECTOR_EFFECT_NON_SCALING_STROKE;
   }
 
   nsStyleImageLayers    mMask;
-  mozilla::StyleClipPath mClipPath;   // [reset]
+  mozilla::StyleShapeSource mClipPath;// [reset]
   nscolor          mStopColor;        // [reset]
   nscolor          mFloodColor;       // [reset]
   nscolor          mLightingColor;    // [reset]
 
   float            mStopOpacity;      // [reset]
   float            mFloodOpacity;     // [reset]
 
   uint8_t          mDominantBaseline; // [reset] see nsStyleConsts.h

--- a/layout/svg/nsCSSClipPathInstance.h
+++ b/layout/svg/nsCSSClipPathInstance.h
@@ -23,17 +23,17 @@ class nsCSSClipPathInstance
 public:
   static void ApplyBasicShapeClip(gfxContext& aContext,
                                   nsIFrame* aFrame);
   // aPoint is in CSS pixels.
   static bool HitTestBasicShapeClip(nsIFrame* aFrame,
                                     const gfxPoint& aPoint);
 private:
   explicit nsCSSClipPathInstance(nsIFrame* aFrame,
-                                 const StyleClipPath aClipPathStyle)
+                                 const StyleShapeSource aClipPathStyle)
     : mTargetFrame(aFrame)
     , mClipPathStyle(aClipPathStyle)
   {
   }
 
   already_AddRefed<Path> CreateClipPath(DrawTarget* aDrawTarget);
 
   already_AddRefed<Path> CreateClipPathCircle(DrawTarget* aDrawTarget,
@@ -48,14 +48,14 @@ private:
   already_AddRefed<Path> CreateClipPathInset(DrawTarget* aDrawTarget,
                                              const nsRect& aRefBox);
 
 
   /**
    * The frame for the element that is currently being clipped.
    */
   nsIFrame* mTargetFrame;
-  StyleClipPath mClipPathStyle;
+  StyleShapeSource mClipPathStyle;
 };
 
 } // namespace mozilla
 
 #endif