--- a/gfx/layers/wr/WebRenderCanvasLayer.cpp
+++ b/gfx/layers/wr/WebRenderCanvasLayer.cpp
@@ -56,19 +56,19 @@ WebRenderCanvasLayer::RenderLayer(wr::Di
 
   gfx::Matrix4x4 transform = GetTransform();
   const bool needsYFlip = (mOriginPos == gl::OriginPos::BottomLeft);
   if (needsYFlip) {
     transform.PreTranslate(0, mBounds.height, 0).PreScale(1, -1, 1);
   }
 
   gfx::Rect relBounds = GetWrRelBounds();
-  gfx::Rect rect = RelativeToVisible(gfx::Rect(0, 0, mBounds.width, mBounds.height));
+  LayerRect rect = RelativeToVisible(LayerRect(0, 0, mBounds.width, mBounds.height));
 
-  gfx::Rect clipRect = GetWrClipRect(rect);
+  LayerRect clipRect = GetWrClipRect(rect);
   Maybe<WrImageMask> mask = BuildWrMaskLayer(true);
   WrClipRegion clip = aBuilder.BuildClipRegion(wr::ToWrRect(clipRect), mask.ptrOr(nullptr));
 
   wr::ImageRendering filter = wr::ToImageRendering(mSamplingFilter);
   wr::MixBlendMode mixBlendMode = wr::ToWrMixBlendMode(GetMixBlendMode());
 
   DumpLayerInfo("CanvasLayer", rect);
   if (gfxPrefs::LayersDump()) {

--- a/gfx/layers/wr/WebRenderColorLayer.cpp
+++ b/gfx/layers/wr/WebRenderColorLayer.cpp
@@ -16,19 +16,19 @@ namespace layers {
 
 using namespace mozilla::gfx;
 
 void
 WebRenderColorLayer::RenderLayer(wr::DisplayListBuilder& aBuilder)
 {
   gfx::Matrix4x4 transform = GetTransform();
   gfx::Rect relBounds = GetWrRelBounds();
-  gfx::Rect rect = GetWrBoundsRect();
+  LayerRect rect = GetWrBoundsRect();
 
-  gfx::Rect clipRect = GetWrClipRect(rect);
+  LayerRect clipRect = GetWrClipRect(rect);
   Maybe<WrImageMask> mask = BuildWrMaskLayer(true);
   WrClipRegion clip = aBuilder.BuildClipRegion(wr::ToWrRect(clipRect), mask.ptrOr(nullptr));
 
   wr::MixBlendMode mixBlendMode = wr::ToWrMixBlendMode(GetMixBlendMode());
 
   DumpLayerInfo("ColorLayer", rect);
 
   aBuilder.PushStackingContext(wr::ToWrRect(relBounds),

--- a/gfx/layers/wr/WebRenderImageLayer.cpp
+++ b/gfx/layers/wr/WebRenderImageLayer.cpp
@@ -142,25 +142,25 @@ WebRenderImageLayer::RenderLayer(wr::Dis
 
   if (mKey.isNothing()) {
     return;
   }
 
   gfx::Matrix4x4 transform = GetTransform();
   gfx::Rect relBounds = GetWrRelBounds();
 
-  gfx::Rect rect = gfx::Rect(0, 0, size.width, size.height);
+  LayerRect rect(0, 0, size.width, size.height);
   if (mScaleMode != ScaleMode::SCALE_NONE) {
     NS_ASSERTION(mScaleMode == ScaleMode::STRETCH,
                  "No other scalemodes than stretch and none supported yet.");
-    rect = gfx::Rect(0, 0, mScaleToSize.width, mScaleToSize.height);
+    rect = LayerRect(0, 0, mScaleToSize.width, mScaleToSize.height);
   }
   rect = RelativeToVisible(rect);
 
-  gfx::Rect clipRect = GetWrClipRect(rect);
+  LayerRect clipRect = GetWrClipRect(rect);
   Maybe<WrImageMask> mask = BuildWrMaskLayer(true);
   WrClipRegion clip = aBuilder.BuildClipRegion(wr::ToWrRect(clipRect), mask.ptrOr(nullptr));
 
   wr::ImageRendering filter = wr::ToImageRendering(mSamplingFilter);
   wr::MixBlendMode mixBlendMode = wr::ToWrMixBlendMode(GetMixBlendMode());
 
   DumpLayerInfo("Image Layer", rect);
   if (gfxPrefs::LayersDump()) {

--- a/gfx/layers/wr/WebRenderLayer.cpp
+++ b/gfx/layers/wr/WebRenderLayer.cpp
@@ -35,22 +35,20 @@ WrImageKey
 WebRenderLayer::GetImageKey()
 {
   WrImageKey key;
   key.mNamespace = WrBridge()->GetNamespace();
   key.mHandle = WrBridge()->GetNextResourceId();
   return key;
 }
 
-Rect
-WebRenderLayer::RelativeToVisible(Rect aRect)
+LayerRect
+WebRenderLayer::RelativeToVisible(const LayerRect& aRect)
 {
-  IntRect bounds = GetLayer()->GetVisibleRegion().GetBounds().ToUnknownRect();
-  aRect.MoveBy(-bounds.x, -bounds.y);
-  return aRect;
+  return aRect - Bounds().TopLeft();
 }
 
 Rect
 WebRenderLayer::RelativeToTransformedVisible(Rect aRect)
 {
   IntRect bounds = GetLayer()->GetVisibleRegion().GetBounds().ToUnknownRect();
   Rect transformed = GetLayer()->GetTransform().TransformBounds(IntRectToRect(bounds));
   aRect.MoveBy(-transformed.x, -transformed.y);
@@ -116,29 +114,30 @@ WebRenderLayer::BuildWrMaskLayer(bool aU
     }
 
     return maskLayer->RenderMaskLayer(transform);
   }
 
   return Nothing();
 }
 
-gfx::Rect
+LayerRect
 WebRenderLayer::GetWrBoundsRect()
 {
-  LayerIntRect bounds = GetLayer()->GetVisibleRegion().GetBounds();
-  return Rect(0, 0, bounds.width, bounds.height);
+  LayerRect bounds = Bounds();
+  bounds.MoveTo(0, 0);
+  return bounds;
 }
 
-gfx::Rect
-WebRenderLayer::GetWrClipRect(gfx::Rect& aRect)
+LayerRect
+WebRenderLayer::GetWrClipRect(const LayerRect& aRect)
 {
   Maybe<LayerRect> clip = ClipRect();
   if (clip) {
-    return RelativeToVisible(clip.ref().ToUnknownRect());
+    return RelativeToVisible(clip.ref());
   }
   return aRect;
 }
 
 LayerRect
 WebRenderLayer::Bounds()
 {
   return LayerRect(GetLayer()->GetVisibleRegion().GetBounds());
@@ -216,24 +215,24 @@ WebRenderLayer::UpdateImageKey(ImageClie
   }
 
   WrImageKey key = GetImageKey();
   WrBridge()->AddWebRenderParentCommand(OpAddExternalImage(aExternalImageId, key));
   return Some(key);
 }
 
 void
-WebRenderLayer::DumpLayerInfo(const char* aLayerType, gfx::Rect& aRect)
+WebRenderLayer::DumpLayerInfo(const char* aLayerType, const LayerRect& aRect)
 {
   if (!gfxPrefs::LayersDump()) {
     return;
   }
 
   Matrix4x4 transform = GetLayer()->GetTransform();
-  Rect clip = GetWrClipRect(aRect);
+  LayerRect clip = GetWrClipRect(aRect);
   Rect relBounds = GetWrRelBounds();
   Rect overflow(0, 0, relBounds.width, relBounds.height);
   WrMixBlendMode mixBlendMode = wr::ToWrMixBlendMode(GetLayer()->GetMixBlendMode());
 
   printf_stderr("%s %p using bounds=%s, overflow=%s, transform=%s, rect=%s, clip=%s, mix-blend-mode=%s\n",
                 aLayerType,
                 GetLayer(),
                 Stringify(relBounds).c_str(),

--- a/gfx/layers/wr/WebRenderLayer.h
+++ b/gfx/layers/wr/WebRenderLayer.h
@@ -41,32 +41,32 @@ public:
                                      ImageContainer* aContainer,
                                      Maybe<wr::ImageKey>& aOldKey,
                                      wr::ExternalImageId& aExternalImageId);
 
   WebRenderLayerManager* WrManager();
   WebRenderBridgeChild* WrBridge();
   WrImageKey GetImageKey();
 
-  gfx::Rect RelativeToVisible(gfx::Rect aRect);
+  LayerRect RelativeToVisible(const LayerRect& aRect);
   gfx::Rect RelativeToTransformedVisible(gfx::Rect aRect);
   gfx::Rect ParentStackingContextBounds();
   gfx::Rect RelativeToParent(gfx::Rect aRect);
   gfx::Rect VisibleBoundsRelativeToParent();
   gfx::Point GetOffsetToParent();
   gfx::Rect TransformedVisibleBoundsRelativeToParent();
 protected:
   LayerRect Bounds();
   BoundsTransformMatrix BoundsTransform();
   LayerRect BoundsForStackingContext();
   Maybe<LayerRect> ClipRect();
 
-  gfx::Rect GetWrBoundsRect();
+  LayerRect GetWrBoundsRect();
   gfx::Rect GetWrRelBounds();
-  gfx::Rect GetWrClipRect(gfx::Rect& aRect);
-  void DumpLayerInfo(const char* aLayerType, gfx::Rect& aRect);
+  LayerRect GetWrClipRect(const LayerRect& aRect);
+  void DumpLayerInfo(const char* aLayerType, const LayerRect& aRect);
   Maybe<WrImageMask> BuildWrMaskLayer(bool aUnapplyLayerTransform);
 };
 
 } // namespace layers
 } // namespace mozilla
 
 #endif /* GFX_WEBRENDERLAYER_H */

--- a/gfx/layers/wr/WebRenderPaintedLayer.cpp
+++ b/gfx/layers/wr/WebRenderPaintedLayer.cpp
@@ -91,19 +91,19 @@ void
 WebRenderPaintedLayer::CreateWebRenderDisplayList(wr::DisplayListBuilder& aBuilder)
 {
   LayerIntRegion visibleRegion = GetVisibleRegion();
   LayerIntRect bounds = visibleRegion.GetBounds();
   LayerIntSize size = bounds.Size();
 
   gfx::Matrix4x4 transform = GetTransform();
   gfx::Rect relBounds = GetWrRelBounds();
-  gfx::Rect rect(0, 0, size.width, size.height);
+  LayerRect rect(0, 0, size.width, size.height);
 
-  gfx::Rect clipRect = GetWrClipRect(rect);
+  LayerRect clipRect = GetWrClipRect(rect);
   Maybe<WrImageMask> mask = BuildWrMaskLayer(true);
   WrClipRegion clip = aBuilder.BuildClipRegion(wr::ToWrRect(clipRect), mask.ptrOr(nullptr));
 
   wr::MixBlendMode mixBlendMode = wr::ToWrMixBlendMode(GetMixBlendMode());
 
   DumpLayerInfo("PaintedLayer", rect);
 
   WrImageKey key = GetImageKey();