Fix invalidation during painting of scrollbars

Source/core/paint/ScrollableAreaPainter.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 #include "core/paint/ScrollableAreaPainter.h"
 
 #include "core/layout/Layer.h"
 #include "core/layout/LayerScrollableArea.h"
 #include "core/layout/LayoutView.h"
 #include "core/layout/PaintInfo.h"
 #include "core/page/Page.h"
 #include "core/paint/ScrollbarPainter.h"
+#include "core/paint/TransformRecorder.h"
 #include "platform/graphics/GraphicsContext.h"
 #include "platform/graphics/GraphicsContextStateSaver.h"
 #include "platform/graphics/paint/DrawingRecorder.h"
 
 namespace blink {
 
 void ScrollableAreaPainter::paintResizer(GraphicsContext* context, const IntPoint& paintOffset, const IntRect& damageRect)
 {
     if (m_renderLayerScrollableArea.box().style()->resize() == RESIZE_NONE)
         return;
@@ skipping 60 matching lines @@
 void ScrollableAreaPainter::paintOverflowControls(GraphicsContext* context, const IntPoint& paintOffset, const IntRect& damageRect, bool paintingOverlayControls)
 {
     // Don't do anything if we have no overflow.
     if (!m_renderLayerScrollableArea.box().hasOverflowClip())
         return;
 
     IntPoint adjustedPaintOffset = paintOffset;
     if (paintingOverlayControls)
         adjustedPaintOffset = m_renderLayerScrollableArea.cachedOverlayScrollbarOffset();
 
-    // Move the scrollbar widgets if necessary. We normally move and resize widgets during layout,
-    // but sometimes widgets can move without layout occurring (most notably when you scroll a
-    // document that contains fixed positioned elements).
-
-    // FIXME: this code should not be necessary.
-    m_renderLayerScrollableArea.positionOverflowControls(toIntSize(adjustedPaintOffset));
+    IntRect localDamageRect = damageRect;
+    localDamageRect.moveBy(-adjustedPaintOffset);
 
     // Overlay scrollbars paint in a second pass through the layer tree so that they will paint
     // on top of everything else. If this is the normal painting pass, paintingOverlayControls
     // will be false, and we should just tell the root layer that there are overlay scrollbars
     // that need to be painted. That will cause the second pass through the layer tree to run,
     // and we'll paint the scrollbars then. In the meantime, cache tx and ty so that the
     // second pass doesn't need to re-enter the RenderTree to get it right.
     if (m_renderLayerScrollableArea.hasOverlayScrollbars() && !paintingOverlayControls) {
         m_renderLayerScrollableArea.setCachedOverlayScrollbarOffset(paintOffset);
         // It's not necessary to do the second pass if the scrollbars paint into layers.
         if ((m_renderLayerScrollableArea.horizontalScrollbar() && m_renderLayerScrollableArea.layerForHorizontalScrollbar()) || (m_renderLayerScrollableArea.verticalScrollbar() && m_renderLayerScrollableArea.layerForVerticalScrollbar()))
             return;
-        IntRect localDamgeRect = damageRect;
-        localDamgeRect.moveBy(-paintOffset);
-        if (!overflowControlsIntersectRect(localDamgeRect))
+        if (!overflowControlsIntersectRect(localDamageRect))
             return;
 
         LayoutView* layoutView = m_renderLayerScrollableArea.box().view();
 
         Layer* paintingRoot = m_renderLayerScrollableArea.layer()->enclosingLayerWithCompositedLayerMapping(IncludeSelf);
         if (!paintingRoot)
             paintingRoot = layoutView->layer();
 
         paintingRoot->setContainsDirtyOverlayScrollbars(true);
         return;
     }
 
     // This check is required to avoid painting custom CSS scrollbars twice.
     if (paintingOverlayControls && !m_renderLayerScrollableArea.hasOverlayScrollbars())
         return;
 
-    // Now that we're sure the scrollbars are in the right place, paint them.
-    if (m_renderLayerScrollableArea.horizontalScrollbar() && !m_renderLayerScrollableArea.layerForHorizontalScrollbar())
-        m_renderLayerScrollableArea.horizontalScrollbar()->paint(context, damageRect);
-    if (m_renderLayerScrollableArea.verticalScrollbar() && !m_renderLayerScrollableArea.layerForVerticalScrollbar())
-        m_renderLayerScrollableArea.verticalScrollbar()->paint(context, damageRect);
+    {
+        TransformRecorder translateRecorder(*context, m_renderLayerScrollableArea.displayItemClient(), AffineTransform::translation(adjustedPaintOffset.x(), adjustedPaintOffset.y()));
+        if (m_renderLayerScrollableArea.horizontalScrollbar() && !m_renderLayerScrollableArea.layerForHorizontalScrollbar())
+            m_renderLayerScrollableArea.horizontalScrollbar()->paint(context, localDamageRect);
+        if (m_renderLayerScrollableArea.verticalScrollbar() && !m_renderLayerScrollableArea.layerForVerticalScrollbar())
+            m_renderLayerScrollableArea.verticalScrollbar()->paint(context, localDamageRect);
+    }
 
     if (m_renderLayerScrollableArea.layerForScrollCorner())
         return;
 
     // We fill our scroll corner with white if we have a scrollbar that doesn't run all the way up to the
     // edge of the box.
     paintScrollCorner(context, adjustedPaintOffset, damageRect);
 
     // Paint our resizer last, since it sits on top of the scroll corner.
     paintResizer(context, adjustedPaintOffset, damageRect);
@@ skipping 35 matching lines @@
     if (recorder.canUseCachedDrawing())
         return;
 
     // We don't want to paint white if we have overlay scrollbars, since we need
     // to see what is behind it.
     if (!m_renderLayerScrollableArea.hasOverlayScrollbars())
         context->fillRect(absRect, Color::white);
 }
 
 } // namespace blink