(WIP) Paint invalidation for slimming paint v2

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
  * modify it under the terms of the GNU Library General Public
@@ skipping 895 matching lines @@
 
     bool hasReflection() const { return m_bitfields.hasReflection(); }
 
     // The current selection state for an object.  For blocks, the state refers to the state of the leaf
     // descendants (as described above in the SelectionState enum declaration).
     SelectionState selectionState() const { return m_bitfields.selectionState(); }
     virtual void setSelectionState(SelectionState state) { m_bitfields.setSelectionState(state); }
     inline void setSelectionStateIfNeeded(SelectionState);
     bool canUpdateSelectionOnRootLineBoxes() const;
 
+    // TODO: Remove for slimming paint v2.
     // A single rectangle that encompasses all of the selected objects within this object.  Used to determine the tightest
     // possible bounding box for the selection. The rect returned is in the coordinate space of the paint invalidation container's backing.
     virtual LayoutRect selectionRectForPaintInvalidation(const LayoutBoxModelObject* /*paintInvalidationContainer*/) const { return LayoutRect(); }
 
     // View coordinates means the coordinate space of |view()|.
     LayoutRect selectionRectInViewCoordinates() const;
 
     virtual bool canBeSelectionLeaf() const { return false; }
     bool hasSelectedChildren() const { return selectionState() != SelectionNone; }
 
@@ skipping 99 matching lines @@
     void setPreviousPositionFromPaintInvalidationBacking(const LayoutPoint& positionFromPaintInvalidationBacking) { m_previousPositionFromPaintInvalidationBacking = positionFromPaintInvalidationBacking; }
 
     PaintInvalidationReason fullPaintInvalidationReason() const { return m_bitfields.fullPaintInvalidationReason(); }
     bool shouldDoFullPaintInvalidation() const { return m_bitfields.fullPaintInvalidationReason() != PaintInvalidationNone; }
     void setShouldDoFullPaintInvalidation(PaintInvalidationReason = PaintInvalidationFull);
     void clearShouldDoFullPaintInvalidation() { m_bitfields.setFullPaintInvalidationReason(PaintInvalidationNone); }
 
     bool shouldInvalidateOverflowForPaint() const { return m_bitfields.shouldInvalidateOverflowForPaint(); }
 
     virtual void clearPaintInvalidationState(const PaintInvalidationState&);
+    void clearSelfPaintInvalidationFlags();
 
     bool mayNeedPaintInvalidation() const { return m_bitfields.mayNeedPaintInvalidation(); }
     void setMayNeedPaintInvalidation();
 
     bool shouldInvalidateSelection() const { return m_bitfields.shouldInvalidateSelection(); }
     void setShouldInvalidateSelection();
 
     bool shouldCheckForPaintInvalidation(const PaintInvalidationState& paintInvalidationState) const
     {
         // Should check for paint invalidation if some ancestor changed location, because this object
         // may also change paint offset or location in paint invalidation container, even if there is
         // no paint invalidation flag set.
         return paintInvalidationState.ancestorHadPaintInvalidationForLocationChange() || shouldCheckForPaintInvalidationRegardlessOfPaintInvalidationState();
     }
 
     bool shouldCheckForPaintInvalidationRegardlessOfPaintInvalidationState() const
     {
-        return mayNeedPaintInvalidation() || shouldDoFullPaintInvalidation() || shouldInvalidateSelection() || m_bitfields.childShouldCheckForPaintInvalidation();
+        return selfShouldCheckForPaintInvalidation() || m_bitfields.childShouldCheckForPaintInvalidation();
+    }
+
+    bool selfShouldCheckForPaintInvalidation() const
+    {
+        return mayNeedPaintInvalidation() || shouldDoFullPaintInvalidation() || shouldInvalidateSelection();
     }
 
     virtual bool supportsPaintInvalidationStateCachedOffsets() const { return !hasTransformRelatedProperty() && !hasReflection() && !style()->isFlippedBlocksWritingMode(); }
 
     virtual LayoutRect viewRect() const;
 
     DisplayItemClient displayItemClient() const { return toDisplayItemClient(this); }
 
     void invalidateDisplayItemClient(const NonLayoutObjectDisplayItemClientWrapper&);
     void invalidateDisplayItemClient(LayoutObject&);
     void invalidateDisplayItemClientForNonCompositingDescendants() { invalidateDisplayItemClientForNonCompositingDescendantsOf(*this); }
     // A normal object should use invalidateDisplayItemClientForNonCompositingDescendants()
     // to invalidate its descendants which are painted on the same backing. However, for
     // an object (e.g. LayoutScrollbarPart, custom scroll corner, custom resizer) which is
     // not hooked up in the layout tree and not able to find its paint backing, it should
     // let its owning layout object call the following function.
     // FIXME: should we hook up scrollbar parts in the layout tree? crbug.com/484263.
     void invalidateDisplayItemClientForNonCompositingDescendantsOf(LayoutObject&);
 
     // Slimming paint v2 tracks whether a LayoutObject is invalid instead of using invalidation rects.
     // For more information, see: https://docs.google.com/a/chromium.org/document/d/1FTqk3MwUAS1qLJsnA9zgfDbeqAQBdLYC4GJ9jpN-xdA
     bool selfNeedsRepaint() const { return m_bitfields.selfNeedsRepaint(); }
     void setNeedsRepaint();
     bool childNeedsRepaint() const { return m_bitfields.childNeedsRepaint(); }
     bool shouldCheckForRepaint() const { return selfNeedsRepaint() || childNeedsRepaint(); }
 
+    virtual PaintInvalidationReason invalidatePaintIfNeededForSlimmingPaintV2(const LayoutPoint& newPaintOffset);
     void clearRepaintFlagsRecursively();
 
 protected:
     enum LayoutObjectType {
         LayoutObjectBr,
         LayoutObjectCanvas,
         LayoutObjectFieldset,
         LayoutObjectCounter,
         LayoutObjectDetailsMarker,
         LayoutObjectEmbeddedObject,
@@ skipping 150 matching lines @@
 
     void markContainerChainForChildNeedsRepaint();
     void setChildNeedsRepaint();
 
     inline void invalidateSelectionIfNeeded(const LayoutBoxModelObject&, PaintInvalidationReason);
 
     inline void invalidateContainerPreferredLogicalWidths();
 
     void invalidatePaintIncludingNonCompositingDescendantsInternal(const LayoutBoxModelObject& repaintContainer);
 
+    // TODO: Remove for slimming paint v2.
     LayoutRect previousSelectionRectForPaintInvalidation() const;
     void setPreviousSelectionRectForPaintInvalidation(const LayoutRect&);
 
     const LayoutBoxModelObject* enclosingCompositedContainer() const;
 
     LayoutFlowThread* locateFlowThreadContainingBlock() const;
     void removeFromLayoutFlowThread();
     void removeFromLayoutFlowThreadRecursive(LayoutFlowThread*);
 
     ComputedStyle* cachedFirstLineStyle() const;
@@ skipping 86 matching lines @@
             , m_isSlowRepaintObject(false)
             , m_selfNeedsRepaint(false)
             , m_childNeedsRepaint(false)
             , m_positionedState(IsStaticallyPositioned)
             , m_selectionState(SelectionNone)
             , m_boxDecorationBackgroundState(NoBoxDecorationBackground)
             , m_fullPaintInvalidationReason(PaintInvalidationNone)
         {
         }
 
-        // 32 bits have been used in the first word, and 18 in the second.
+        // 32 bits have been used in the first word, and 19 in the second.
         ADD_BOOLEAN_BITFIELD(selfNeedsLayout, SelfNeedsLayout);
         ADD_BOOLEAN_BITFIELD(shouldInvalidateOverflowForPaint, ShouldInvalidateOverflowForPaint); // TODO(wangxianzhu): Remove for slimming paint v2.
         ADD_BOOLEAN_BITFIELD(childShouldCheckForPaintInvalidation, ChildShouldCheckForPaintInvalidation);
         ADD_BOOLEAN_BITFIELD(mayNeedPaintInvalidation, MayNeedPaintInvalidation);
         ADD_BOOLEAN_BITFIELD(shouldInvalidateSelection, ShouldInvalidateSelection); // TODO(wangxianzhu): Remove for slimming paint v2.
         ADD_BOOLEAN_BITFIELD(neededLayoutBecauseOfChildren, NeededLayoutBecauseOfChildren); // TODO(wangxianzhu): Remove for slimming paint v2.
         ADD_BOOLEAN_BITFIELD(needsPositionedMovementLayout, NeedsPositionedMovementLayout);
         ADD_BOOLEAN_BITFIELD(normalChildNeedsLayout, NormalChildNeedsLayout);
         ADD_BOOLEAN_BITFIELD(posChildNeedsLayout, PosChildNeedsLayout);
         ADD_BOOLEAN_BITFIELD(needsSimplifiedNormalFlowLayout, NeedsSimplifiedNormalFlowLayout);
@@ skipping 88 matching lines @@
     void setShouldInvalidateOverflowForPaint(bool b) { m_bitfields.setShouldInvalidateOverflowForPaint(b); }
     void setSelfNeedsOverflowRecalcAfterStyleChange(bool b) { m_bitfields.setSelfNeedsOverflowRecalcAfterStyleChange(b); }
     void setChildNeedsOverflowRecalcAfterStyleChange(bool b) { m_bitfields.setChildNeedsOverflowRecalcAfterStyleChange(b); }
 
 private:
     // Store state between styleWillChange and styleDidChange
     static bool s_affectsParentBlock;
 
     // This stores the paint invalidation rect from the previous frame. This rect does *not* account for composited scrolling. See
     // adjustInvalidationRectForCompositedScrolling().
+    // TODO: Remove for slimming paint v2.
     LayoutRect m_previousPaintInvalidationRect;
 
     // This stores the position in the paint invalidation backing's coordinate.
     // It is used to detect layoutObject shifts that forces a full invalidation.
     // This point does *not* account for composited scrolling. See adjustInvalidationRectForCompositedScrolling().
-    LayoutPoint m_previousPositionFromPaintInvalidationBacking;
+    union {
+        LayoutPoint m_previousPositionFromPaintInvalidationBacking; // TODO: Remove for slimming paint v2.
+        // For slimming paint v2: previous paint offset in the space of the nearest transform container.
+        LayoutPoint m_previousPaintOffset;
+    };
 };
 
 // FIXME: remove this once the layout object lifecycle ASSERTS are no longer hit.
 class DeprecatedDisableModifyLayoutTreeStructureAsserts {
     WTF_MAKE_NONCOPYABLE(DeprecatedDisableModifyLayoutTreeStructureAsserts);
 public:
     DeprecatedDisableModifyLayoutTreeStructureAsserts();
 
     static bool canModifyLayoutTreeStateInAnyState();
 
@@ skipping 216 matching lines @@
 void showTree(const blink::LayoutObject*);
 void showLineTree(const blink::LayoutObject*);
 void showLayoutTree(const blink::LayoutObject* object1);
 // We don't make object2 an optional parameter so that showLayoutTree
 // can be called from gdb easily.
 void showLayoutTree(const blink::LayoutObject* object1, const blink::LayoutObject* object2);
 
 #endif
 
 #endif // LayoutObject_h