--- a/gfx/layers/basic/BasicCompositor.cpp
+++ b/gfx/layers/basic/BasicCompositor.cpp
@@ -281,42 +281,40 @@ BasicCompositor::CreateRenderTargetFromS
                                               const CompositingRenderTarget *aSource,
                                               const IntPoint &aSourcePoint)
 {
   MOZ_CRASH("GFX: Shouldn't be called!");
   return nullptr;
 }
 
 already_AddRefed<CompositingRenderTarget>
-BasicCompositor::CreateRenderTargetForWindow(const LayoutDeviceIntRect& aRect, const LayoutDeviceIntRect& aClearRect, BufferMode aBufferMode)
+BasicCompositor::CreateRenderTargetForWindow(const LayoutDeviceIntRect& aInvalidRect,
+                                             const LayoutDeviceIntRect& aClearRect,
+                                             const IntRect& aWindowRect,
+                                             BufferMode aBufferMode)
 {
   MOZ_ASSERT(mDrawTarget);
-  MOZ_ASSERT(!aRect.IsZeroArea(), "Trying to create a render target of invalid size");
+  MOZ_ASSERT(!aInvalidRect.IsZeroArea(), "Trying to create a render target of invalid size");
 
-  if (aRect.IsZeroArea()) {
+  if (aInvalidRect.IsZeroArea()) {
     return nullptr;
   }
 
   RefPtr<BasicCompositingRenderTarget> rt;
-  IntRect rect = aRect.ToUnknownRect();
+  IntRect rect = aInvalidRect.ToUnknownRect();
 
   if (aBufferMode != BufferMode::BUFFER_NONE) {
-    RefPtr<DrawTarget> target = mWidget->GetBackBufferDrawTarget(mDrawTarget, aRect, aClearRect);
+    RefPtr<DrawTarget> target = mWidget->GetBackBufferDrawTarget(mDrawTarget, aInvalidRect, aClearRect);
     if (!target) {
       return nullptr;
     }
     MOZ_ASSERT(target != mDrawTarget);
     rt = new BasicCompositingRenderTarget(target, rect);
   } else {
-    IntRect windowRect = rect;
-    // Adjust bounds rect to account for new origin at (0, 0).
-    if (windowRect.Size() != mDrawTarget->GetSize()) {
-      windowRect.ExpandToEnclose(IntPoint(0, 0));
-    }
-    rt = new BasicCompositingRenderTarget(mDrawTarget, windowRect);
+    rt = new BasicCompositingRenderTarget(mDrawTarget, aWindowRect);
     if (!aClearRect.IsEmpty()) {
       IntRect clearRect = aClearRect.ToUnknownRect();
       mDrawTarget->ClearRect(Rect(clearRect - rt->GetOrigin()));
     }
   }
 
   return rt.forget();
 }
@@ -951,19 +949,17 @@ BasicCompositor::BeginFrame(const nsIntR
 
   // Prevent CreateRenderTargetForWindow from clearing unwanted area.
   gfxUtils::ClipToRegion(mDrawTarget,
                          mInvalidRegion.ToUnknownRegion());
 
   // Setup an intermediate render target to buffer all compositing. We will
   // copy this into mDrawTarget (the widget), and/or mTarget in EndFrame()
   RefPtr<CompositingRenderTarget> target =
-    CreateRenderTargetForWindow(mInvalidRect,
-                                clearRect,
-                                bufferMode);
+    CreateRenderTargetForWindow(mInvalidRect, clearRect, rect, bufferMode);
 
   mDrawTarget->PopClip();
 
   if (!target) {
     if (!mTarget) {
       mWidget->EndRemoteDrawingInRegion(mDrawTarget, mInvalidRegion);
     }
     return;

--- a/gfx/layers/basic/BasicCompositor.h
+++ b/gfx/layers/basic/BasicCompositor.h
@@ -65,16 +65,17 @@ public:
   virtual already_AddRefed<CompositingRenderTarget>
   CreateRenderTargetFromSource(const gfx::IntRect &aRect,
                                const CompositingRenderTarget *aSource,
                                const gfx::IntPoint &aSourcePoint) override;
 
   virtual already_AddRefed<CompositingRenderTarget>
   CreateRenderTargetForWindow(const LayoutDeviceIntRect& aRect,
                               const LayoutDeviceIntRect& aClearRect,
+                              const gfx::IntRect& aWindowRect,
                               BufferMode aBufferMode);
 
   virtual already_AddRefed<DataTextureSource>
   CreateDataTextureSource(TextureFlags aFlags = TextureFlags::NO_FLAGS) override;
 
   virtual already_AddRefed<DataTextureSource>
   CreateDataTextureSourceAround(gfx::DataSourceSurface* aSurface) override;