--- a/gfx/layers/TiledLayerBuffer.h
+++ b/gfx/layers/TiledLayerBuffer.h
@@ -553,25 +553,25 @@ TiledLayerBuffer<Derived, Tile>::Update(
       newRetainedTiles[index] = newTile;
 
       y += height;
     }
 
     x += width;
   }
 
-  mRetainedTiles = newRetainedTiles;
   AsDerived().PostValidate(aPaintRegion);
-  for (unsigned int i = 0; i < mRetainedTiles.Length(); ++i) {
-    AsDerived().UnlockTile(mRetainedTiles[i]);
+  for (unsigned int i = 0; i < newRetainedTiles.Length(); ++i) {
+    AsDerived().UnlockTile(newRetainedTiles[i]);
   }
 
   // At this point, oldTileCount should be zero
   MOZ_ASSERT(oldTileCount == 0, "Failed to release old tiles");
 
+  mRetainedTiles = newRetainedTiles;
   mValidRegion = newValidRegion;
   mPaintedRegion.Or(mPaintedRegion, aPaintRegion);
 }
 
 } // layers
 } // mozilla
 
 #endif // GFX_TILEDLAYERBUFFER_H

--- a/gfx/layers/client/TiledContentClient.cpp
+++ b/gfx/layers/client/TiledContentClient.cpp
@@ -512,17 +512,16 @@ TileClient::TileClient(const TileClient&
   mFrontLock = o.mFrontLock;
   mCompositableClient = o.mCompositableClient;
 #ifdef GFX_TILEDLAYER_DEBUG_OVERLAY
   mLastUpdate = o.mLastUpdate;
 #endif
   mManager = o.mManager;
   mInvalidFront = o.mInvalidFront;
   mInvalidBack = o.mInvalidBack;
-  mOrigin = o.mOrigin;
 }
 
 TileClient&
 TileClient::operator=(const TileClient& o)
 {
   if (this == &o) return *this;
   mBackBuffer.Set(this, o.mBackBuffer);
   mBackBufferOnWhite = o.mBackBufferOnWhite;
@@ -532,17 +531,16 @@ TileClient::operator=(const TileClient& 
   mFrontLock = o.mFrontLock;
   mCompositableClient = o.mCompositableClient;
 #ifdef GFX_TILEDLAYER_DEBUG_OVERLAY
   mLastUpdate = o.mLastUpdate;
 #endif
   mManager = o.mManager;
   mInvalidFront = o.mInvalidFront;
   mInvalidBack = o.mInvalidBack;
-  mOrigin = o.mOrigin;
   return *this;
 }
 
 
 void
 TileClient::Flip()
 {
 #if defined(MOZ_WIDGET_GONK) && ANDROID_VERSION >= 17
@@ -1053,41 +1051,16 @@ ClientTiledLayerBuffer::PostValidate(con
       ctx->CurrentMatrix().Scale(mResolution, mResolution).Translate(ThebesPoint(-mTilingOrigin)));
 
     mCallback(mPaintedLayer, ctx, aPaintRegion, DrawRegionClip::DRAW, nsIntRegion(), mCallbackData);
     mMoz2DTiles.clear();
     // Reset:
     mTilingOrigin = IntPoint(std::numeric_limits<int32_t>::max(),
                              std::numeric_limits<int32_t>::max());
   }
-
-  for (size_t i = 0; i < mRetainedTiles.Length(); ++i) {
-    TileClient& tile = mRetainedTiles[i];
-    if (tile.mFrontBuffer && tile.mFrontBuffer->IsLocked()) {
-      // Only worry about padding when not doing low-res because it simplifies
-      // the math and the artifacts won't be noticable
-      // Edge padding prevents sampling artifacts when compositing.
-      if (mResolution == 1) {
-        nsIntRect unscaledTile = nsIntRect(tile.mOrigin.x, tile.mOrigin.y,
-                                           GetTileSize().width, GetTileSize().height);
-        nsIntRegion tileValidRegion = GetValidRegion();
-        tileValidRegion.OrWith(aPaintRegion);
-
-        // We only need to pad out if the tile has area that's not valid
-        if (!tileValidRegion.Contains(unscaledTile)) {
-          tileValidRegion = tileValidRegion.Intersect(unscaledTile);
-          // translate the region into tile space and pad
-          tileValidRegion.MoveBy(-nsIntPoint(unscaledTile.x, unscaledTile.y));
-          RefPtr<DrawTarget> drawTarget = tile.mFrontBuffer->BorrowDrawTarget();
-          PadDrawTargetOutFromRegion(drawTarget, tileValidRegion);
-        }
-      }
-    }
-  }
-
 }
 
 void
 ClientTiledLayerBuffer::UnlockTile(TileClient aTile)
 {
   // We locked the back buffer, and flipped so we now need to unlock the front
   if (aTile.mFrontBuffer && aTile.mFrontBuffer->IsLocked()) {
     aTile.mFrontBuffer->Unlock();
@@ -1166,18 +1139,16 @@ ClientTiledLayerBuffer::ValidateTile(Til
     if (!backBufferOnWhite->Lock(OpenMode::OPEN_READ_WRITE)) {
       NS_WARNING("Failed to lock tile TextureClient for updating.");
       aTile.DiscardBackBuffer();
       aTile.DiscardFrontBuffer();
       return TileClient();
     }
   }
 
-  aTile.mOrigin = gfx::ToIntPoint(aTileOrigin);
-
   if (usingTiledDrawTarget) {
     if (createdTextureClient) {
       if (!mCompositableClient->AddTextureClient(backBuffer)) {
         NS_WARNING("Failed to add tile TextureClient.");
         aTile.DiscardFrontBuffer();
         aTile.DiscardBackBuffer();
         return aTile;
       }
@@ -1271,16 +1242,36 @@ ClientTiledLayerBuffer::ValidateTile(Til
                           drawRect.height);
     gfx::IntPoint copyTarget(NS_lroundf(drawRect.x), NS_lroundf(drawRect.y));
     drawTarget->CopySurface(source, copyRect, copyTarget);
 
     // Mark the newly updated area as invalid in the front buffer
     aTile.mInvalidFront.Or(aTile.mInvalidFront, nsIntRect(copyTarget.x, copyTarget.y, copyRect.width, copyRect.height));
   }
 
+  // only worry about padding when not doing low-res
+  // because it simplifies the math and the artifacts
+  // won't be noticable
+  if (mResolution == 1) {
+    nsIntRect unscaledTile = nsIntRect(aTileOrigin.x,
+                                       aTileOrigin.y,
+                                       GetTileSize().width,
+                                       GetTileSize().height);
+
+    nsIntRegion tileValidRegion = GetValidRegion();
+    tileValidRegion.Or(tileValidRegion, aDirtyRegion);
+    // We only need to pad out if the tile has area that's not valid
+    if (!tileValidRegion.Contains(unscaledTile)) {
+      tileValidRegion = tileValidRegion.Intersect(unscaledTile);
+      // translate the region into tile space and pad
+      tileValidRegion.MoveBy(-nsIntPoint(unscaledTile.x, unscaledTile.y));
+      PadDrawTargetOutFromRegion(drawTarget, tileValidRegion);
+    }
+  }
+
   // The new buffer is now validated, remove the dirty region from it.
   aTile.mInvalidBack.SubOut(offsetScaledDirtyRegion);
 
 #ifdef GFX_TILEDLAYER_DEBUG_OVERLAY
   DrawDebugOverlay(drawTarget, aTileOrigin.x * mResolution,
                    aTileOrigin.y * GetPresShellResolution(), GetTileLength(), GetTileLength());
 #endif
 

--- a/gfx/layers/client/TiledContentClient.h
+++ b/gfx/layers/client/TiledContentClient.h
@@ -269,18 +269,16 @@ struct TileClient
   CompositableClient* mCompositableClient;
 #ifdef GFX_TILEDLAYER_DEBUG_OVERLAY
   TimeStamp        mLastUpdate;
 #endif
   nsIntRegion mInvalidFront;
   nsIntRegion mInvalidBack;
   nsExpirationState mExpirationState;
 
-  gfx::IntPoint mOrigin;
-
 private:
   // Copies dirty pixels from the front buffer into the back buffer,
   // and records the copied region in aAddPaintedRegion.
   void ValidateBackBufferFromFront(const nsIntRegion &aDirtyRegion,
                                    nsIntRegion& aAddPaintedRegion);
 };
 
 /**