Ensure invalidation of non-composited scrollbars on resize

Source/core/rendering/RenderBox.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com)
  *           (C) 2005, 2006 Samuel Weinig (sam.weinig@gmail.com)
  * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2013 Adobe Systems Incorporated. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
@@ skipping 1289 matching lines @@
     return false;
 }
 
 PaintInvalidationReason RenderBox::invalidatePaintIfNeeded(const PaintInvalidationState& paintInvalidationState, const RenderLayerModelObject& newPaintInvalidationContainer)
 {
     PaintInvalidationReason reason = RenderBoxModelObject::invalidatePaintIfNeeded(paintInvalidationState, newPaintInvalidationContainer);
 
     // If we are set to do a full paint invalidation that means the RenderView will be
     // issue paint invalidations. We can then skip issuing of paint invalidations for the child
     // renderers as they'll be covered by the RenderView.
-    if (!view()->doingFullPaintInvalidation()) {
-        if (!isFullPaintInvalidationReason(reason))
-            invalidatePaintForOverflowIfNeeded();
+    if (!view()->doingFullPaintInvalidation() && !isFullPaintInvalidationReason(reason)) {
+        invalidatePaintForOverflowIfNeeded();
 
         // Issue paint invalidations for any scrollbars if there is a scrollable area for this renderer.
         if (ScrollableArea* area = scrollableArea()) {
             if (area->hasVerticalBarDamage())
                 invalidatePaintRectangle(area->verticalBarDamage());
             if (area->hasHorizontalBarDamage())
                 invalidatePaintRectangle(area->horizontalBarDamage());
         }
     }
 
@@ skipping 2434 matching lines @@
 {
     // Checkboxes and radioboxes are not isReplaced() nor do they have their own renderer in which to override avoidFloats().
     return node && node->isElementNode() && toElement(node)->isFormControlElement();
 }
 
 bool RenderBox::avoidsFloats() const
 {
     return isReplaced() || isReplacedElement(node()) || hasOverflowClip() || isHR() || isLegend() || isWritingModeRoot() || isFlexItemIncludingDeprecated();
 }
 
+bool RenderBox::hasNonCompositedScrollbars() const
+{
+    if (RenderLayer* layer = this->layer()) {
+        if (RenderLayerScrollableArea* scrollableArea = layer->scrollableArea()) {
+            if (scrollableArea->hasHorizontalScrollbar() && !scrollableArea->layerForHorizontalScrollbar())
+                return true;
+            if (scrollableArea->hasVerticalScrollbar() && !scrollableArea->layerForVerticalScrollbar())
+                return true;
+        }
+    }
+    return false;
+}
+
 PaintInvalidationReason RenderBox::paintInvalidationReason(const RenderLayerModelObject& paintInvalidationContainer,
     const LayoutRect& oldBounds, const LayoutPoint& oldLocation, const LayoutRect& newBounds, const LayoutPoint& newLocation) const
 {
     PaintInvalidationReason invalidationReason = RenderBoxModelObject::paintInvalidationReason(paintInvalidationContainer, oldBounds, oldLocation, newBounds, newLocation);
     if (isFullPaintInvalidationReason(invalidationReason))
         return invalidationReason;
 
     // If the transform is not identity or translation, incremental invalidation is not applicable
     // because the difference between oldBounds and newBounds doesn't cover all area needing invalidation.
     // FIXME: Should also consider ancestor transforms since paintInvalidationContainer. crbug.com/426111.
     if (invalidationReason == PaintInvalidationIncremental
         && paintInvalidationContainer != this
         && hasLayer() && layer()->transform() && !layer()->transform()->isIdentityOrTranslation())
         return PaintInvalidationBoundsChange;
 
-    if (!style()->hasBackground() && !style()->hasBoxDecorations())
+    if (!style()->hasBackground() && !style()->hasBoxDecorations()) {
+        // We could let incremental invalidation cover non-composited scrollbars, but just
+        // do a full invalidation because incremental invalidation will go away with slimming paint.
+        if (invalidationReason == PaintInvalidationIncremental && hasNonCompositedScrollbars())
+            return PaintInvalidationBorderBoxChange;
         return invalidationReason;
+    }
 
     LayoutSize oldBorderBoxSize = computePreviousBorderBoxSize(oldBounds.size());
     LayoutSize newBorderBoxSize = size();
 
     if (oldBorderBoxSize == newBorderBoxSize)
         return invalidationReason;
 
+    // See another hasNonCompositedScrollbars() callsite above.
+    if (hasNonCompositedScrollbars())
+        return PaintInvalidationBorderBoxChange;
+
     // FIXME: Implement correct incremental invalidation for visual overflowing effects.
     if (style()->hasVisualOverflowingEffect() || style()->hasAppearance() || style()->hasFilter())
         return PaintInvalidationBorderBoxChange;
 
     if (style()->hasBorderRadius()) {
         // If a border-radius exists and width/height is smaller than radius width/height,
         // we need to fully invalidate to cover the changed radius.
         RoundedRect oldRoundedRect = style()->getRoundedBorderFor(LayoutRect(LayoutPoint(0, 0), oldBorderBoxSize));
         RoundedRect newRoundedRect = style()->getRoundedBorderFor(LayoutRect(LayoutPoint(0, 0), newBorderBoxSize));
         if (oldRoundedRect.radii() != newRoundedRect.radii())
@@ skipping 638 matching lines @@
 
     setLogicalTop(oldLogicalTop);
     setLogicalWidth(oldLogicalWidth);
     setMarginLeft(oldMarginLeft);
     setMarginRight(oldMarginRight);
 
     return borderBox;
 }
 
 } // namespace blink