Skip paint property update and visual rect update if no geometry change

third_party/WebKit/Source/core/layout/LayoutObject.h

Index: third_party/WebKit/Source/core/layout/LayoutObject.h
diff --git a/third_party/WebKit/Source/core/layout/LayoutObject.h b/third_party/WebKit/Source/core/layout/LayoutObject.h
index 52203ef7d78deed99d9c2e611e0d0a1adbd08440..b4922700c450e776f80e14db4fc291469f64099e 100644
--- a/third_party/WebKit/Source/core/layout/LayoutObject.h
+++ b/third_party/WebKit/Source/core/layout/LayoutObject.h
@@ -1643,6 +1643,8 @@ class CORE_EXPORT LayoutObject : public ImageResourceObserver,
   }
   void setShouldDoFullPaintInvalidation(
       PaintInvalidationReason = PaintInvalidationFull);
+  void setShouldDoFullPaintInvalidationWithoutGeometryChange(

[pdr., 2017/03/10 06:21:39]

It looks like this change is basically recognizing that some paint invalidation
changes don't need paint properties so we can leave the properties untouched. Is
that correct?

If so, I wonder if we could make the distinction more explicit? No need to go
implement this, I am just trying to see if I understand the problem.
Could we break apart our invalidation bits into:
1) a set of bits for pure paint invalidation (e.g., color changes)
2) a set of bits for paint offset invalidation
3) a set of bits for property invalidation
We could then early-out of the whole walk if nothing is set. Paint invalidation
walk must continue if the 1 or 2 are set. Property tree building must continue
if 2 or 3 are set. This lets us early-out from the paint invalidation code in a
similar way that this patch early-outs from the property tree building code.

[Xianzhu, 2017/03/10 17:43:05]

Yes.
I think with the patch we have a set of flags that are basically equivalent to
your proposal:
1) mayNeedPaintInvalidation and fullPaintInvalidationReasons;
2) needsPaintOffsetAndVisualRectUpdate
3) needsPaintPropertyUpdate

The patch is different from your proposal at the API level: I let
setMayNeedPaintInvalidation() and setShouldDoFullPaintInvalidation() set both 1
and 2, and add functions with "WithoutGeometryChange" to set 1 only. This is
because the cases that can use "WithoutGeometyChange" are fewer than those
needing geometry change. If we set 1 and 2 separately at API level, we would
need to change one call to two calls for each of the remaining
setMayNeedPaintInvalidation() and setShouldDoFullPaintInvalidation() calls.

+      PaintInvalidationReason = PaintInvalidationFull);
   void clearShouldDoFullPaintInvalidation() {
     m_bitfields.setFullPaintInvalidationReason(PaintInvalidationNone);
   }
@@ -1653,12 +1655,17 @@ class CORE_EXPORT LayoutObject : public ImageResourceObserver,
     return m_bitfields.mayNeedPaintInvalidation();
   }
   void setMayNeedPaintInvalidation();
+  void setMayNeedPaintInvalidationWithoutGeometryChange();
 
   bool mayNeedPaintInvalidationSubtree() const {
     return m_bitfields.mayNeedPaintInvalidationSubtree();
   }
   void setMayNeedPaintInvalidationSubtree();
 
+  bool needsPaintOffsetAndVisualRectUpdate() const {
+    return m_bitfields.needsPaintOffsetAndVisualRectUpdate();
+  }
+
   bool mayNeedPaintInvalidationAnimatedBackgroundImage() const {
     return m_bitfields.mayNeedPaintInvalidationAnimatedBackgroundImage();
   }
@@ -1677,9 +1684,7 @@ class CORE_EXPORT LayoutObject : public ImageResourceObserver,
 
   bool shouldCheckForPaintInvalidationRegardlessOfPaintInvalidationState()
       const {
-    return mayNeedPaintInvalidation() || shouldDoFullPaintInvalidation() ||
-           shouldInvalidateSelection() ||
-           m_bitfields.childShouldCheckForPaintInvalidation();
+    return mayNeedPaintInvalidation() || shouldDoFullPaintInvalidation();
   }
 
   virtual LayoutRect viewRect() const;
@@ -2016,7 +2021,8 @@ class CORE_EXPORT LayoutObject : public ImageResourceObserver,
 #if DCHECK_IS_ON()
   virtual bool paintInvalidationStateIsDirty() const {
     return backgroundChangedSinceLastPaintInvalidation() ||
-           shouldCheckForPaintInvalidationRegardlessOfPaintInvalidationState();
+           shouldCheckForPaintInvalidationRegardlessOfPaintInvalidationState() ||
+           shouldInvalidateSelection() || needsPaintOffsetAndVisualRectUpdate();
   }
 #endif
 
@@ -2101,6 +2107,7 @@ class CORE_EXPORT LayoutObject : public ImageResourceObserver,
   inline void markAncestorsForOverflowRecalcIfNeeded();
 
   inline void markAncestorsForPaintInvalidation();
+  inline void setNeedsPaintOffsetAndVisualRectUpdate();
 
   inline void invalidateContainerPreferredLogicalWidths();
 
@@ -2197,10 +2204,10 @@ class CORE_EXPORT LayoutObject : public ImageResourceObserver,
           m_selfNeedsOverflowRecalcAfterStyleChange(false),
           m_childNeedsOverflowRecalcAfterStyleChange(false),
           m_preferredLogicalWidthsDirty(false),
-          m_childShouldCheckForPaintInvalidation(false),
           m_mayNeedPaintInvalidation(false),
           m_mayNeedPaintInvalidationSubtree(false),
           m_mayNeedPaintInvalidationAnimatedBackgroundImage(false),
+          m_needsPaintOffsetAndVisualRectUpdate(false),
           m_shouldInvalidateSelection(false),
           m_floating(false),
           m_isAnonymous(!node),
@@ -2299,13 +2306,13 @@ class CORE_EXPORT LayoutObject : public ImageResourceObserver,
     ADD_BOOLEAN_BITFIELD(preferredLogicalWidthsDirty,
                          PreferredLogicalWidthsDirty);
 
-    ADD_BOOLEAN_BITFIELD(childShouldCheckForPaintInvalidation,
-                         ChildShouldCheckForPaintInvalidation);
     ADD_BOOLEAN_BITFIELD(mayNeedPaintInvalidation, MayNeedPaintInvalidation);
     ADD_BOOLEAN_BITFIELD(mayNeedPaintInvalidationSubtree,
                          MayNeedPaintInvalidationSubtree);
     ADD_BOOLEAN_BITFIELD(mayNeedPaintInvalidationAnimatedBackgroundImage,
                          MayNeedPaintInvalidationAnimatedBackgroundImage);
+    ADD_BOOLEAN_BITFIELD(needsPaintOffsetAndVisualRectUpdate,
+                         NeedsPaintOffsetAndVisualRectUpdate);
     ADD_BOOLEAN_BITFIELD(shouldInvalidateSelection, ShouldInvalidateSelection);
 
     // This boolean is the cached value of 'float'