Tweak priorities of paint invalidation reasons

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 87 matching lines @@
     if (!rectClippedByNewBounds.contains(rectClippedByOldBounds))
         m_box.invalidatePaintUsingContainer(*m_context.paintInvalidationContainer, rectClippedByOldBounds, PaintInvalidationIncremental);
     if (!rectClippedByOldBounds.contains(rectClippedByNewBounds))
         m_box.invalidatePaintUsingContainer(*m_context.paintInvalidationContainer, rectClippedByNewBounds, PaintInvalidationIncremental);
 }
 
 PaintInvalidationReason BoxPaintInvalidator::computePaintInvalidationReason()
 {
     PaintInvalidationReason reason = ObjectPaintInvalidator(m_box, m_context).computePaintInvalidationReason();
 
-    if (reason != PaintInvalidationDelayedFull && isFullPaintInvalidationReason(reason))
+    if (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.
@@ skipping 38 matching lines @@
         if (previousBoxSizesMap().get(&m_box).layoutOverflowRect != m_box.layoutOverflowRect())
             return PaintInvalidationLayoutOverflowBoxChange;
     }
 
     LayoutSize oldBorderBoxSize = computePreviousBorderBoxSize(m_context.oldBounds.size());
     LayoutSize newBorderBoxSize = m_box.size();
 
     if (oldBorderBoxSize == newBorderBoxSize)
         return reason;
 
-    // LayoutBox::incrementallyInvalidatePaint() depends on positionFromPaintInvalidationBacking
-    // which is not available when slimmingPaintOffsetCachingEnabled.
-    if (RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled() && (style.hasBoxDecorations() || style.hasBackground()))
-        return PaintInvalidationBorderBoxChange;
-
     // See another hasNonCompositedScrollbars() callsite above.
     if (m_box.hasNonCompositedScrollbars())
         return PaintInvalidationBorderBoxChange;
 
     if (style.hasVisualOverflowingEffect() || style.hasAppearance() || style.hasFilterInducingProperty() || style.resize() != RESIZE_NONE)
         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.
         FloatRoundedRect oldRoundedRect = style.getRoundedBorderFor(LayoutRect(LayoutPoint(0, 0), oldBorderBoxSize));
         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()))
+    if (reason == PaintInvalidationProbablyNone && (style.hasBackground() || style.hasBoxDecorations()))

[pdr., 2016/08/15 23:37:42]

Could we just return PaintInvalidationIncremental directly instead of modifying
the invalidation reason here?

I don't really understand the PaintInvalidationProbablyNone invalidation reason.
Can you think of a name that is more concrete?

[Xianzhu, 2016/08/16 01:13:54]

Added comments in PaintInvalidationReason.h.

For the following cases (assuming the object is a box and
shouldDoFullPaintInvalidation() is false):
1. both old bounds and new bounds are empty,
2. old bounds and new bounds are non-empty and equal,
  2.1. old and new border boxes equals,
  2.2. old and new border box don't equal,
    2.2.1 the box has background or box decorations,
    2.2.2 the box doesn't have background or box decorations,
3. old bounds and new bounds have the same location but don't equal:

Case   ObjectPaintInvalidator         BoxPaintInvalidator
1      PaintInvalidationNone          PaintInvalidationNone
2.1    PaintInvalidationProbablyNone  PaintInvalidationProbablyNone
2.2.1  PaintInvalidationProbablyNone  PaintInvalidationProbablyNone
2.2.2  PaintInvalidationProbablyNone  PaintInvalidationIncremental
3      PaintInvalidationIncremental   PaintInvalidationIncremental

Previously ObjectPaintInvalidator::computePaintInvalidationReason() returned
PaintInvalidationNone for both case 1 and case 2 though the function can already
be sure no paint invalidation is needed for case 1.

         reason = PaintInvalidationIncremental;
 
     return reason;
 }
 
 PaintInvalidationReason BoxPaintInvalidator::invalidatePaintIfNeeded()
 {
     PaintInvalidationReason reason = ObjectPaintInvalidator(m_box, m_context).invalidatePaintIfNeededWithComputedReason(computePaintInvalidationReason());
 
     // For incremental invalidation, ObjectPaintInvalidator::incrementallyInvalidatePaint() is
@@ skipping 65 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