--- a/gfx/layers/wr/StackingContextHelper.cpp
+++ b/gfx/layers/wr/StackingContextHelper.cpp
@@ -19,18 +19,16 @@ StackingContextHelper::StackingContextHe
 
 StackingContextHelper::StackingContextHelper(const StackingContextHelper& aParentSC,
                                              wr::DisplayListBuilder& aBuilder,
                                              WebRenderLayer* aLayer,
                                              const Maybe<gfx::Matrix4x4>& aTransform)
   : mBuilder(&aBuilder)
 {
   WrRect scBounds = aParentSC.ToRelativeWrRect(aLayer->BoundsForStackingContext());
-  mOffsetToParent.x = scBounds.x;
-  mOffsetToParent.y = scBounds.y;
   Layer* layer = aLayer->GetLayer();
   mTransform = aTransform.valueOr(layer->GetTransform());
   mBuilder->PushStackingContext(scBounds,
                                 1.0f,
                                 mTransform,
                                 wr::ToWrMixBlendMode(layer->GetMixBlendMode()));
   mOrigin = aLayer->Bounds().TopLeft();
 }
@@ -39,18 +37,16 @@ StackingContextHelper::StackingContextHe
                                              wr::DisplayListBuilder& aBuilder,
                                              WebRenderLayer* aLayer,
                                              uint64_t aAnimationsId,
                                              float* aOpacityPtr,
                                              gfx::Matrix4x4* aTransformPtr)
   : mBuilder(&aBuilder)
 {
   WrRect scBounds = aParentSC.ToRelativeWrRect(aLayer->BoundsForStackingContext());
-  mOffsetToParent.x = scBounds.x;
-  mOffsetToParent.y = scBounds.y;
   if (aTransformPtr) {
     mTransform = *aTransformPtr;
   }
   mBuilder->PushStackingContext(scBounds,
                                 aAnimationsId,
                                 aOpacityPtr,
                                 aTransformPtr,
                                 wr::ToWrMixBlendMode(aLayer->GetLayer()->GetMixBlendMode()));
@@ -84,17 +80,17 @@ StackingContextHelper::ToRelativeWrPoint
 
 WrRect
 StackingContextHelper::ToRelativeWrRectRounded(const LayoutDeviceRect& aRect) const
 {
   return wr::ToWrRect(RoundedToInt(ViewAs<LayerPixel>(aRect, PixelCastJustification::WebRenderHasUnitResolution) - mOrigin));
 }
 
 gfx::Matrix4x4
-StackingContextHelper::TransformToParentSC() const
+StackingContextHelper::TransformToRoot() const
 {
   gfx::Matrix4x4 inv = mTransform.Inverse();
-  inv.PostTranslate(-mOffsetToParent.x, -mOffsetToParent.y, 0);
+  inv.PostTranslate(-mOrigin.x, -mOrigin.y, 0);
   return inv;
 }
 
 } // namespace layers
 } // namespace mozilla

--- a/gfx/layers/wr/StackingContextHelper.h
+++ b/gfx/layers/wr/StackingContextHelper.h
@@ -60,22 +60,21 @@ public:
   WrRect ToRelativeWrRect(const LayerRect& aRect) const;
   WrRect ToRelativeWrRect(const LayoutDeviceRect& aRect) const;
   // Same but for points
   WrPoint ToRelativeWrPoint(const LayerPoint& aPoint) const;
   // Same but rounds the rectangle to ints after transforming.
   WrRect ToRelativeWrRectRounded(const LayoutDeviceRect& aRect) const;
 
   // Produce a transform that converts points from the coordinate space of this
-  // stacking context to the coordinate space of the parent stacking context.
-  gfx::Matrix4x4 TransformToParentSC() const;
+  // stacking context to the coordinate space of the root of the layer tree.
+  gfx::Matrix4x4 TransformToRoot() const;
 
 private:
   wr::DisplayListBuilder* mBuilder;
   LayerPoint mOrigin;
-  WrPoint mOffsetToParent;
   gfx::Matrix4x4 mTransform;
 };
 
 } // namespace layers
 } // namespace mozilla
 
 #endif /* GFX_STACKINGCONTEXTHELPER_H */

--- a/gfx/layers/wr/WebRenderLayer.cpp
+++ b/gfx/layers/wr/WebRenderLayer.cpp
@@ -47,17 +47,17 @@ WebRenderLayer::BuildWrMaskLayer(const S
     WebRenderLayer* maskLayer = ToWebRenderLayer(GetLayer()->GetMaskLayer());
 
     // If |this| layer is pushing a stacking context, that should be passed in
     // as |aUnapplySc|. We need to unapply the transform from that stacking
     // context because the mask layer (according to WR) is outside that stacking
     // context.
     gfx::Matrix4x4 transform = maskLayer->GetLayer()->GetTransform();
     if (aUnapplySc) {
-      transform = transform * aUnapplySc->TransformToParentSC();
+      transform = transform * aUnapplySc->TransformToRoot();
     }
 
     return maskLayer->RenderMaskLayer(transform);
   }
 
   return Nothing();
 }