CL for perf tryjob on mac

third_party/WebKit/Source/core/paint/BoxPaintInvalidator.cpp

 // Copyright 2016 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 "core/paint/BoxPaintInvalidator.h"
 
 #include "core/frame/Settings.h"
 #include "core/layout/LayoutView.h"
 #include "core/paint/ObjectPaintInvalidator.h"
 #include "core/paint/PaintInvalidator.h"
@@ skipping 16 matching lines @@
     return map;
 }
 
 void BoxPaintInvalidator::boxWillBeDestroyed(const LayoutBox& box)
 {
     previousBoxSizesMap().remove(&box);
 }
 
 bool BoxPaintInvalidator::incrementallyInvalidatePaint()
 {
-    bool result = ObjectPaintInvalidatorWithContext(m_box, m_context).incrementallyInvalidatePaint();
+    bool result = false; // ObjectPaintInvalidatorWithContext(m_box, m_context).incrementallyInvalidatePaint();
 
     bool hasBoxDecorations = m_box.styleRef().hasBoxDecorations();
     if (!m_box.styleRef().hasBackground() && !hasBoxDecorations)
         return result;
 
     const LayoutRect& oldBounds = m_context.oldBounds;
     const LayoutRect& newBounds = m_context.newBounds;
 
     LayoutSize oldBorderBoxSize = computePreviousBorderBoxSize(oldBounds.size());
     LayoutSize newBorderBoxSize = m_box.size();
@@ skipping 54 matching lines @@
     if (!rectClippedByNewBounds.contains(rectClippedByOldBounds))
         objectPaintInvalidator.invalidatePaintUsingContainer(*m_context.paintInvalidationContainer, rectClippedByOldBounds, PaintInvalidationIncremental);
     if (!rectClippedByOldBounds.contains(rectClippedByNewBounds))
         objectPaintInvalidator.invalidatePaintUsingContainer(*m_context.paintInvalidationContainer, rectClippedByNewBounds, PaintInvalidationIncremental);
 }
 
 PaintInvalidationReason BoxPaintInvalidator::computePaintInvalidationReason()
 {
     PaintInvalidationReason reason = ObjectPaintInvalidatorWithContext(m_box, m_context).computePaintInvalidationReason();
 
-    if (isImmediateFullPaintInvalidationReason(reason) || reason == PaintInvalidationNone)
+    if (reason != PaintInvalidationDelayedFull && isFullPaintInvalidationReason(reason))
+    // isImmediateFullPaintInvalidationReason(reason) || reason == PaintInvalidationNone)
         return reason;
 
     if (m_box.mayNeedPaintInvalidationAnimatedBackgroundImage() && !m_box.backgroundIsKnownToBeObscured())
         reason = PaintInvalidationDelayedFull;
 
     // If the current paint invalidation reason is PaintInvalidationDelayedFull, then this paint invalidation can delayed if the
     // LayoutBox in question is not on-screen. The logic to decide whether this is appropriate exists at the site of the original
     // paint invalidation that chose PaintInvalidationDelayedFull.
     if (reason == PaintInvalidationDelayedFull) {
         // Do regular full paint invalidation if the object is onscreen.
         return m_box.intersectsVisibleViewport() ? PaintInvalidationFull : PaintInvalidationDelayedFull;
     }
 
     if (m_box.isLayoutView()) {
         const LayoutView& layoutView = toLayoutView(m_box);
         // In normal compositing mode, root background doesn't need to be invalidated for
         // box changes, because the background always covers the whole document rect
         // and clipping is done by compositor()->m_containerLayer. Also the scrollbars
         // are always composited. There are no other box decoration on the LayoutView thus
         // we can safely exit here.
         if (layoutView.usesCompositing() && (!layoutView.document().settings() || !layoutView.document().settings()->rootLayerScrolls()))
             return reason;
     }
 
     // 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 (reason == PaintInvalidationIncremental
-        && m_context.oldBounds != m_context.newBounds
+        // && m_context.oldBounds != m_context.newBounds
         && m_context.paintInvalidationContainer != m_box
         && m_box.hasLayer() && m_box.layer()->transform()
         && !m_box.layer()->transform()->isIdentityOrTranslation())
         return PaintInvalidationBoundsChange;
 
     const ComputedStyle& style = m_box.styleRef();
     if (style.backgroundLayers().thisOrNextLayersUseContentBox() || style.maskLayers().thisOrNextLayersUseContentBox() || style.boxSizing() == BoxSizingBorderBox) {
         if (previousBoxSizesMap().get(&m_box).contentBoxRect != m_box.contentBoxRect())
             return PaintInvalidationContentBoxChange;
     }
 
     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 (reason == PaintInvalidationIncremental && m_context.oldBounds != m_context.newBounds && m_box.hasNonCompositedScrollbars())
+        if (reason == PaintInvalidationIncremental && /* m_context.oldBounds != m_context.newBounds && */ m_box.hasNonCompositedScrollbars())
             return PaintInvalidationBorderBoxChange;
         return reason;
     }
 
     if (style.backgroundLayers().thisOrNextLayersHaveLocalAttachment()) {
         if (previousBoxSizesMap().get(&m_box).layoutOverflowRect != m_box.layoutOverflowRect())
             return PaintInvalidationLayoutOverflowBoxChange;
     }
 
     LayoutSize oldBorderBoxSize = computePreviousBorderBoxSize(m_context.oldBounds.size());
@@ skipping 16 matching lines @@
         FloatRoundedRect newRoundedRect = style.getRoundedBorderFor(LayoutRect(LayoutPoint(0, 0), newBorderBoxSize));
         if (oldRoundedRect.getRadii() != newRoundedRect.getRadii())
             return PaintInvalidationBorderBoxChange;
     }
 
     if (oldBorderBoxSize.width() != newBorderBoxSize.width() && m_box.mustInvalidateBackgroundOrBorderPaintOnWidthChange())
         return PaintInvalidationBorderBoxChange;
     if (oldBorderBoxSize.height() != newBorderBoxSize.height() && m_box.mustInvalidateBackgroundOrBorderPaintOnHeightChange())
         return PaintInvalidationBorderBoxChange;
 
+    if (reason == PaintInvalidationNone && (style.hasBackground() || style.hasBoxDecorations()))
+        reason = PaintInvalidationIncremental;
+
     return reason;
 }
 
 PaintInvalidationReason BoxPaintInvalidator::invalidatePaintIfNeeded()
 {
+    PaintInvalidationReason reason = ObjectPaintInvalidatorWithContext(m_box, m_context).invalidatePaintIfNeededWithComputedReason(computePaintInvalidationReason());
+
+    if (reason == PaintInvalidationIncremental)
+        incrementallyInvalidatePaint();
+
+    /*
     PaintInvalidationReason reason = computePaintInvalidationReason();
     if (reason == PaintInvalidationIncremental) {
         if (incrementallyInvalidatePaint()) {
             m_context.paintingLayer->setNeedsRepaint();
             m_box.invalidateDisplayItemClients(reason);
         } else {
             reason = PaintInvalidationNone;
         }
         // Though we have done our own version of incremental invalidation, we still need to call
         // ObjectPaintInvalidator with PaintInvalidationNone to do any other required operations.
         reason = std::max(reason, ObjectPaintInvalidatorWithContext(m_box, m_context).invalidatePaintIfNeededWithComputedReason(PaintInvalidationNone));
     } else {
         reason = ObjectPaintInvalidatorWithContext(m_box, m_context).invalidatePaintIfNeededWithComputedReason(reason);
     }
+    */
 
     if (PaintLayerScrollableArea* area = m_box.getScrollableArea())
         area->invalidatePaintOfScrollControlsIfNeeded(m_context);
 
     // This is for the next invalidatePaintIfNeeded so must be at the end.
     savePreviousBoxSizesIfNeeded();
 
     return reason;
 }
 
@@ skipping 51 matching lines @@
 
     auto it = previousBoxSizesMap().find(&m_box);
     if (it != previousBoxSizesMap().end())
         return it->value.borderBoxSize;
 
     // We didn't save the old border box size because it was the same as the size of oldBounds.
     return previousBoundsSize;
 }
 
 } // namespace blink