Replace LayoutObject::skipInvalidationWhenLaidOutChildren() with paintedOutputOfObjectHasNoEffect

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
  * modify it under the terms of the GNU Library General Public
@@ skipping 336 matching lines @@
     }
 
     void assertSubtreeClearedPaintInvalidationFlags() const
     {
         for (const LayoutObject* layoutObject = this; layoutObject; layoutObject = layoutObject->nextInPreOrder())
             layoutObject->assertClearedPaintInvalidationFlags();
     }
 
 #endif
 
-    // Correct version of !layoutObjectHasNoBoxEffectObsolete().
-    bool hasBoxEffect() const
-    {
-        return hasBoxDecorationBackground() || style()->hasVisualOverflowingEffect();
-    }

[Xianzhu, 2016/08/03 19:56:36]

This is now directly inlined in the new
LayoutBox::canSkipUnforcedPaintInvalidation().

-
     // LayoutObject tree manipulation
     //////////////////////////////////////////
     virtual bool canHaveChildren() const { return virtualChildren(); }
     virtual bool isChildAllowed(LayoutObject*, const ComputedStyle&) const { return true; }
 
     // This function is called whenever a child is inserted under |this|.
     //
     // The main purpose of this function is to generate a consistent layout
     // tree, which means generating the missing anonymous objects. Most of the
     // time there'll be no anonymous objects to generate.
@@ skipping 64 matching lines @@
     void setNeedsLayoutIsForbidden(bool flag) { m_setNeedsLayoutForbidden = flag; }
 #endif
 
     void addAbsoluteRectForLayer(IntRect& result);
     bool requiresAnonymousTableWrappers(const LayoutObject*) const;
 
     // Gets pseudoStyle from Shadow host(in case of input elements)
     // or from Parent element.
     PassRefPtr<ComputedStyle> getUncachedPseudoStyleFromParentOrShadowHost() const;
 
-    bool skipInvalidationWhenLaidOutChildren() const;
-
 public:
 #ifndef NDEBUG
     void showTreeForThis() const;
     void showLayoutTreeForThis() const;
     void showLineTreeForThis() const;
 
     void showLayoutObject() const;
     // We don't make stringBuilder an optional parameter so that
     // showLayoutObject can be called from gdb easily.
     void showLayoutObject(StringBuilder&) const;
@@ skipping 228 matching lines @@
     enum BoxDecorationBackgroundState {
         NoBoxDecorationBackground,
         HasBoxDecorationBackgroundObscurationStatusInvalid,
         HasBoxDecorationBackgroundKnownToBeObscured,
         HasBoxDecorationBackgroundMayBeVisible,
     };
     bool hasBoxDecorationBackground() const { return m_bitfields.getBoxDecorationBackgroundState() != NoBoxDecorationBackground; }
     bool boxDecorationBackgroundIsKnownToBeObscured() const;
     bool hasBackground() const { return style()->hasBackground(); }
 
-    bool needsLayoutBecauseOfChildren() const { return needsLayout() && !selfNeedsLayout() && !needsPositionedMovementLayout() && !needsSimplifiedNormalFlowLayout(); }
-
     bool needsLayout() const
     {
         return m_bitfields.selfNeedsLayout() || m_bitfields.normalChildNeedsLayout() || m_bitfields.posChildNeedsLayout()
             || m_bitfields.needsSimplifiedNormalFlowLayout() || m_bitfields.needsPositionedMovementLayout();
     }
 
     bool selfNeedsLayout() const { return m_bitfields.selfNeedsLayout(); }
     bool needsPositionedMovementLayout() const { return m_bitfields.needsPositionedMovementLayout(); }
 
     bool posChildNeedsLayout() const { return m_bitfields.posChildNeedsLayout(); }
@@ skipping 415 matching lines @@
     // Invalidate the paint of a specific subrectangle within a given object. The rect is in the object's coordinate space.
     void invalidatePaintRectangle(const LayoutRect&) const;
 
     // Walk the tree after layout issuing paint invalidations for layoutObjects that have changed or moved, updating bounds that have changed, and clearing paint invalidation state.
     virtual void invalidateTreeIfNeeded(const PaintInvalidationState&);
 
     void invalidatePaintIncludingNonCompositingDescendants();
     void invalidatePaintIncludingNonSelfPaintingLayerDescendants(const LayoutBoxModelObject& paintInvalidationContainer);
     void setShouldDoFullPaintInvalidationIncludingNonCompositingDescendants();
 
+    // An object needs to check unforced paint invalidation if it's not set shouldDoFullPaintInvalidation,

[chrishtr, 2016/08/03 20:33:51]

Maybe rewrite as:

"unforced paint invalidation is when shouldDoFullPaintInvalidation is false, but
mayNeedPaintInvalidation or childShouldCheckForPaintInvalidation is true. This
returns
true if the object has unforced paint invalidation bits set, but they can be
skipped because its painting geometry will not change for some reason"

[Xianzhu, 2016/08/03 21:30:35]

Done.

+    // but is set mayNeedPaintInvalidation or childShouldCheckForPaintInvalidation. The object can
+    // skip unforced paint invalidation if its painting will not be affected by geometry change.
+    virtual bool canSkipUnforcedPaintInvalidation() const { return false; }
+
     // Returns the rect that should have paint invalidated whenever this object changes. The rect is in the view's
     // coordinate space. This method deals with outlines and overflow.
     virtual LayoutRect absoluteClippedOverflowRect() const;
 
     // Returns the rect that should have paint invalidated whenever this object changes. The rect is in the object's
     // local coordinate space. This is for non-SVG objects and LayoutSVGRoot only. SVG objects (except LayoutSVGRoot)
     // should use paintInvalidationRectInLocalSVGCoordinates() and map with SVG transforms instead.
     virtual LayoutRect localOverflowRectForPaintInvalidation() const;
 
     // Given a rect in the object's coordinate space, mutates the rect into one representing the size of its visual painted
@@ skipping 404 matching lines @@
     //
     // If we don't meet the criteria for an incremental paint, the
     // alternative is a full paint invalidation.
     virtual void incrementallyInvalidatePaint(const LayoutBoxModelObject& paintInvalidationContainer, const LayoutRect& oldBounds, const LayoutRect& newBounds, const LayoutPoint& positionFromPaintInvalidationBacking);
 
     virtual bool hasNonCompositedScrollbars() const { return false; }
 
 #if ENABLE(ASSERT)
     virtual bool paintInvalidationStateIsDirty() const
     {
-        return m_bitfields.neededLayoutBecauseOfChildren() || shouldCheckForPaintInvalidationRegardlessOfPaintInvalidationState();
+        return shouldCheckForPaintInvalidationRegardlessOfPaintInvalidationState();
     }
 #endif
 
     // This function walks the descendants of |this|, following a
     // layout ordering.
     //
     // The ordering is important for PaintInvalidationState, as
     // it requires to be called following a descendant/container
     // relationship.
     //
@@ skipping 172 matching lines @@
             , 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_shouldInvalidateSelection(false)
-            , m_neededLayoutBecauseOfChildren(false)
             , m_floating(false)
             , m_isAnonymous(!node)
             , m_isText(false)
             , m_isBox(false)
             , m_isInline(true)
             , m_isAtomicInlineLevel(false)
             , m_horizontalWritingMode(true)
             , m_isDragging(false)
             , m_hasLayer(false)
             , m_hasOverflowClip(false)
@@ skipping 13 matching lines @@
             , m_lastBoxDecorationBackgroundObscured(false)
             , m_isBackgroundAttachmentFixedObject(false)
             , m_isScrollAnchorObject(false)
             , m_positionedState(IsStaticallyPositioned)
             , m_selectionState(SelectionNone)
             , m_boxDecorationBackgroundState(NoBoxDecorationBackground)
             , m_fullPaintInvalidationReason(PaintInvalidationNone)
         {
         }
 
-        // 32 bits have been used in the first word, and 17 in the second.
+        // 32 bits have been used in the first word, and 16 in the second.
 
         // Self needs layout means that this layout object is marked for a full layout.
         // This is the default layout but it is expensive as it recomputes everything.
         // For CSS boxes, this includes the width (laying out the line boxes again), the margins
         // (due to block collapsing margins), the positions, the height and the potential overflow.
         ADD_BOOLEAN_BITFIELD(selfNeedsLayout, SelfNeedsLayout);
 
         // A positioned movement layout is a specialized type of layout used on positioned objects
         // that only visually moved. This layout is used when changing 'top'/'left' on a positioned
         // element or margins on an out-of-flow one. Because the following operations don't impact
@@ skipping 30 matching lines @@
 
         // 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(shouldInvalidateSelection, ShouldInvalidateSelection); // TODO(wangxianzhu): Remove for slimming paint v2.
-        ADD_BOOLEAN_BITFIELD(neededLayoutBecauseOfChildren, NeededLayoutBecauseOfChildren); // TODO(wangxianzhu): Remove for slimming paint v2.
+        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);
 
         // This boolean represents whether the LayoutObject is 'inline-level'
@@ skipping 196 matching lines @@
 {
     setNeedsLayout(reason, markParents, layouter);
     setShouldDoFullPaintInvalidation();
 }
 
 inline void LayoutObject::clearNeedsLayout()
 {
     // Set flags for later stages/cycles.
     setEverHadLayout();
     setMayNeedPaintInvalidation();
-    m_bitfields.setNeededLayoutBecauseOfChildren(needsLayoutBecauseOfChildren());
 
     // Clear needsLayout flags.
     setSelfNeedsLayout(false);
     setPosChildNeedsLayout(false);
     setNeedsSimplifiedNormalFlowLayout(false);
     setNormalChildNeedsLayout(false);
     setNeedsPositionedMovementLayout(false);
     setAncestorLineBoxDirty(false);
 
 #if ENABLE(ASSERT)
@@ skipping 122 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