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

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

 /*
  * Copyright (C) 2000 Lars Knoll (knoll@kde.org)
  *           (C) 2000 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
  *           (C) 2004 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2012 Apple Inc.
  *               All rights reserved.
  * Copyright (C) 2009 Google Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 1625 matching lines @@
   const LayoutPoint& paintOffset() const { return m_paintOffset; }
 
   PaintInvalidationReason fullPaintInvalidationReason() const {
     return m_bitfields.fullPaintInvalidationReason();
   }
   bool shouldDoFullPaintInvalidation() const {
     return m_bitfields.fullPaintInvalidationReason() != PaintInvalidationNone;
   }
   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);
   }
 
   void clearPaintInvalidationFlags();
 
   bool mayNeedPaintInvalidation() const {
     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();
   }
   void setMayNeedPaintInvalidationAnimatedBackgroundImage();
 
   bool shouldInvalidateSelection() const {
     return m_bitfields.shouldInvalidateSelection();
   }
   void setShouldInvalidateSelection();
 
   bool shouldCheckForPaintInvalidation(
       const PaintInvalidationState& paintInvalidationState) const {
     return paintInvalidationState.hasForcedSubtreeInvalidationFlags() ||
            shouldCheckForPaintInvalidationRegardlessOfPaintInvalidationState();
   }
 
   bool shouldCheckForPaintInvalidationRegardlessOfPaintInvalidationState()
       const {
-    return mayNeedPaintInvalidation() || shouldDoFullPaintInvalidation() ||
-           shouldInvalidateSelection() ||
-           m_bitfields.childShouldCheckForPaintInvalidation();
+    return mayNeedPaintInvalidation() || shouldDoFullPaintInvalidation();
   }
 
   virtual LayoutRect viewRect() const;
 
   // New version to replace the above old version.
   virtual PaintInvalidationReason invalidatePaintIfNeeded(
       const PaintInvalidatorContext&) const;
 
   // When this object is invalidated for paint, this method is called to
   // invalidate any DisplayItemClients owned by this object, including the
@@ skipping 316 matching lines @@
   // layerOffset is the offset of this layoutObject within the current layer
   // that should be used for each result.
   virtual void computeSelfHitTestRects(Vector<LayoutRect>&,
                                        const LayoutPoint& layerOffset) const {}
 
   void setVisualRect(const LayoutRect& rect) { m_visualRect = rect; }
 
 #if DCHECK_IS_ON()
   virtual bool paintInvalidationStateIsDirty() const {
     return backgroundChangedSinceLastPaintInvalidation() ||
-           shouldCheckForPaintInvalidationRegardlessOfPaintInvalidationState();
+           shouldCheckForPaintInvalidationRegardlessOfPaintInvalidationState() ||
+           shouldInvalidateSelection() || needsPaintOffsetAndVisualRectUpdate();
   }
 #endif
 
   // Called before paint invalidation.
   virtual void ensureIsReadyForPaintInvalidation() { DCHECK(!needsLayout()); }
 
   // This function walks the descendants of |this|, following a
   // layout ordering.
   //
   // The ordering is important for PaintInvalidationState, as it requires to be
@@ skipping 64 matching lines @@
 
   // Walk up the parent chain and find the first scrolling block to disable
   // scroll anchoring on.
   void setScrollAnchorDisablingStyleChangedOnAncestor();
 
   // FIXME: This should be 'markContaingBoxChainForOverflowRecalc when we make
   // LayoutBox recomputeOverflow-capable. crbug.com/437012 and crbug.com/434700.
   inline void markAncestorsForOverflowRecalcIfNeeded();
 
   inline void markAncestorsForPaintInvalidation();
+  inline void setNeedsPaintOffsetAndVisualRectUpdate();
 
   inline void invalidateContainerPreferredLogicalWidths();
 
   void invalidatePaintIncludingNonSelfPaintingLayerDescendantsInternal(
       const LayoutBoxModelObject& paintInvalidationContainer);
 
   LayoutObject* containerForAbsolutePosition(AncestorSkipInfo* = nullptr) const;
 
   const LayoutBoxModelObject* enclosingCompositedContainer() const;
 
@@ skipping 76 matching lines @@
     // of the memory constraints on layout objects.
     LayoutObjectBitfields(Node* node)
         : m_selfNeedsLayout(false),
           m_needsPositionedMovementLayout(false),
           m_normalChildNeedsLayout(false),
           m_posChildNeedsLayout(false),
           m_needsSimplifiedNormalFlowLayout(false),
           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),
           m_isText(false),
           m_isBox(false),
           m_isInline(true),
           m_isAtomicInlineLevel(false),
           m_horizontalWritingMode(true),
           m_hasLayer(false),
           m_hasOverflowClip(false),
@@ skipping 78 matching lines @@
     ADD_BOOLEAN_BITFIELD(childNeedsOverflowRecalcAfterStyleChange,
                          ChildNeedsOverflowRecalcAfterStyleChange);
 
     // This boolean marks preferred logical widths for lazy recomputation.
     //
     // See INTRINSIC SIZES / PREFERRED LOGICAL WIDTHS above about those
     // widths.
     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'
     // (see ComputedStyle::isFloating).
     ADD_BOOLEAN_BITFIELD(floating, Floating);
 
     ADD_BOOLEAN_BITFIELD(isAnonymous, IsAnonymous);
     ADD_BOOLEAN_BITFIELD(isText, IsText);
     ADD_BOOLEAN_BITFIELD(isBox, IsBox);
 
@@ skipping 458 matching lines @@
 CORE_EXPORT void showLineTree(const blink::LayoutObject*);
 CORE_EXPORT void showLayoutTree(const blink::LayoutObject* object1);
 // We don't make object2 an optional parameter so that showLayoutTree
 // can be called from gdb easily.
 CORE_EXPORT void showLayoutTree(const blink::LayoutObject* object1,
                                 const blink::LayoutObject* object2);
 
 #endif
 
 #endif  // LayoutObject_h