First step of PaintInvalidator implementation

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

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
  *           (C) 2004 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2009 Google Inc. All rights reserved.
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 51 matching lines @@
 #include "core/layout/LayoutScrollbarPart.h"
 #include "core/layout/LayoutTableCaption.h"
 #include "core/layout/LayoutTableCell.h"
 #include "core/layout/LayoutTableCol.h"
 #include "core/layout/LayoutTableRow.h"
 #include "core/layout/LayoutTheme.h"
 #include "core/layout/LayoutView.h"
 #include "core/layout/ng/layout_ng_block_flow.h"
 #include "core/page/AutoscrollController.h"
 #include "core/page/Page.h"
+#include "core/paint/ObjectPaintInvalidator.h"
 #include "core/paint/ObjectPaintProperties.h"
 #include "core/paint/PaintLayer.h"
 #include "core/style/ContentData.h"
 #include "core/style/CursorData.h"
 #include "platform/HostWindow.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/TracedValue.h"
 #include "platform/geometry/TransformState.h"
 #include "wtf/allocator/Partitions.h"
 #include "wtf/text/StringBuilder.h"
@@ skipping 44 matching lines @@
     unsigned m_bitfields;
     unsigned m_bitfields2;
     LayoutRect rect; // Stores the previous paint invalidation rect.
     LayoutPoint position; // Stores the previous position from the paint invalidation container.
 };
 
 static_assert(sizeof(LayoutObject) == sizeof(SameSizeAsLayoutObject), "LayoutObject should stay small");
 
 bool LayoutObject::s_affectsParentBlock = false;
 
-typedef HashMap<const LayoutObject*, LayoutRect> SelectionPaintInvalidationMap;
-static SelectionPaintInvalidationMap* selectionPaintInvalidationMap = nullptr;
-
 // The pointer to paint properties is implemented as a global hash map temporarily,
 // to avoid memory regression during the transition towards SPv2.
 typedef HashMap<const LayoutObject*, std::unique_ptr<ObjectPaintProperties>> ObjectPaintPropertiesMap;
 static ObjectPaintPropertiesMap& objectPaintPropertiesMap()
 {
     DEFINE_STATIC_LOCAL(ObjectPaintPropertiesMap, staticObjectPaintPropertiesMap, ());
     return staticObjectPaintPropertiesMap;
 }
 
 void* LayoutObject::operator new(size_t sz)
@@ skipping 952 matching lines @@
 void addJsonObjectForRect(TracedValue* value, const char* name, const T& rect)
 {
     value->beginDictionary(name);
     value->setDouble("x", rect.x());
     value->setDouble("y", rect.y());
     value->setDouble("width", rect.width());
     value->setDouble("height", rect.height());
     value->endDictionary();
 }
 
-template <typename T>
-void addJsonObjectForPoint(TracedValue* value, const char* name, const T& point)
-{
-    value->beginDictionary(name);
-    value->setDouble("x", point.x());
-    value->setDouble("y", point.y());
-    value->endDictionary();
-}
-
 static std::unique_ptr<TracedValue> jsonObjectForPaintInvalidationInfo(const LayoutRect& rect, const String& invalidationReason)
 {
     std::unique_ptr<TracedValue> value = TracedValue::create();
     addJsonObjectForRect(value.get(), "rect", rect);
     value->setString("invalidation_reason", invalidationReason);
     return value;
 }
 
 static void invalidatePaintRectangleOnWindow(const LayoutBoxModelObject& paintInvalidationContainer, const IntRect& dirtyRect)
 {
@@ skipping 70 matching lines @@
 {
     if (PaintLayer* paintingLayer = this->paintingLayer())
         paintingLayer->setNeedsRepaint();
 }
 
 void LayoutObject::invalidateDisplayItemClients(PaintInvalidationReason reason) const
 {
     invalidateDisplayItemClient(*this, reason);
 }
 
-void LayoutObject::invalidateDisplayItemClientsWithPaintInvalidationState(const PaintInvalidationState& paintInvalidationState, PaintInvalidationReason reason) const
-{
-    paintInvalidationState.paintingLayer().setNeedsRepaint();
-    invalidateDisplayItemClients(reason);
-}
-
 bool LayoutObject::compositedScrollsWithRespectTo(const LayoutBoxModelObject& paintInvalidationContainer) const
 {
     return paintInvalidationContainer.usesCompositedScrolling() && this != &paintInvalidationContainer;
 }
 
 IntSize LayoutObject::scrollAdjustmentForPaintInvalidation(const LayoutBoxModelObject& paintInvalidationContainer) const
 {
     // Non-composited scrolling should be included in the bounds of scrolled items. Since mapToVisualRectInAncestorSpace does not include
     // scrolling of the ancestor, we need to add it back in after.
     if (paintInvalidationContainer.isBox() && !paintInvalidationContainer.usesCompositedScrolling() && this != &paintInvalidationContainer) {
@@ skipping 20 matching lines @@
     dirtyRectOnBacking.move(scrollAdjustmentForPaintInvalidation(paintInvalidationContainer));
 
     invalidatePaintUsingContainer(paintInvalidationContainer, dirtyRectOnBacking, PaintInvalidationRectangle);
 
     slowSetPaintingLayerNeedsRepaint();
     invalidateDisplayItemClients(PaintInvalidationRectangle);
 }
 
 void LayoutObject::invalidateTreeIfNeeded(const PaintInvalidationState& paintInvalidationState)
 {
-    ASSERT(!needsLayout());
+    ensureIsReadyForPaintInvalidation();
 
     // If we didn't need paint invalidation then our children don't need as well.
     // Skip walking down the tree as everything should be fine below us.
     if (!shouldCheckForPaintInvalidation(paintInvalidationState))
         return;
 
     PaintInvalidationState newPaintInvalidationState(paintInvalidationState, *this);
 
     if (mayNeedPaintInvalidationSubtree())
         newPaintInvalidationState.setForceSubtreeInvalidationCheckingWithinContainer();
 
     PaintInvalidationReason reason = invalidatePaintIfNeeded(newPaintInvalidationState);
-    clearPaintInvalidationFlags(newPaintInvalidationState);
+    clearPaintInvalidationFlags();
 
     newPaintInvalidationState.updateForChildren(reason);
     invalidatePaintOfSubtreesIfNeeded(newPaintInvalidationState);
 }
 
 void LayoutObject::invalidatePaintOfSubtreesIfNeeded(const PaintInvalidationState& childPaintInvalidationState)
 {
     for (LayoutObject* child = slowFirstChild(); child; child = child->nextSibling()) {
         // Column spanners are invalidated through their placeholders.
         // See LayoutMultiColumnSpannerPlaceholder::invalidatePaintOfSubtreesIfNeeded().
         if (child->isColumnSpanAll())
             continue;
         child->invalidateTreeIfNeeded(childPaintInvalidationState);
     }
 }
 
-static std::unique_ptr<TracedValue> jsonObjectForOldAndNewRects(const LayoutRect& oldRect, const LayoutPoint& oldLocation, const LayoutRect& newRect, const LayoutPoint& newLocation)
-{
-    std::unique_ptr<TracedValue> value = TracedValue::create();
-    addJsonObjectForRect(value.get(), "oldRect", oldRect);
-    addJsonObjectForPoint(value.get(), "oldLocation", oldLocation);
-    addJsonObjectForRect(value.get(), "newRect", newRect);
-    addJsonObjectForPoint(value.get(), "newLocation", newLocation);
-    return value;
-}
-
 LayoutRect LayoutObject::selectionRectInViewCoordinates() const
 {
     LayoutRect selectionRect = localSelectionRect();
     if (!selectionRect.isEmpty())
         mapToVisualRectInAncestorSpace(view(), selectionRect);
     return selectionRect;
 }
 
-LayoutRect LayoutObject::previousSelectionRectForPaintInvalidation() const
-{
-    if (!selectionPaintInvalidationMap)
-        return LayoutRect();
-
-    return selectionPaintInvalidationMap->get(this);
-}
-
-void LayoutObject::setPreviousSelectionRectForPaintInvalidation(const LayoutRect& selectionRect)
-{
-    if (!selectionPaintInvalidationMap) {
-        if (selectionRect.isEmpty())
-            return;
-        selectionPaintInvalidationMap = new SelectionPaintInvalidationMap();
-    }
-
-    if (selectionRect.isEmpty())
-        selectionPaintInvalidationMap->remove(this);
-    else
-        selectionPaintInvalidationMap->set(this, selectionRect);
-}
-
-inline void LayoutObject::invalidateSelectionIfNeeded(const LayoutBoxModelObject& paintInvalidationContainer, const PaintInvalidationState& paintInvalidationState, PaintInvalidationReason invalidationReason)
-{
-    // Update selection rect when we are doing full invalidation (in case that the object is moved, composite status changed, etc.)
-    // or shouldInvalidationSelection is set (in case that the selection itself changed).
-    bool fullInvalidation = isFullPaintInvalidationReason(invalidationReason);
-    if (!fullInvalidation && !shouldInvalidateSelection())
-        return;
-
-    LayoutRect oldSelectionRect = previousSelectionRectForPaintInvalidation();
-    LayoutRect newSelectionRect = localSelectionRect();
-    if (!newSelectionRect.isEmpty())
-        paintInvalidationState.mapLocalRectToPaintInvalidationBacking(newSelectionRect);
-
-    newSelectionRect.move(scrollAdjustmentForPaintInvalidation(paintInvalidationContainer));
-
-    setPreviousSelectionRectForPaintInvalidation(newSelectionRect);
-
-    if (!fullInvalidation) {
-        fullyInvalidatePaint(paintInvalidationContainer, PaintInvalidationSelection, oldSelectionRect, newSelectionRect);
-        invalidateDisplayItemClientsWithPaintInvalidationState(paintInvalidationState, PaintInvalidationSelection);
-    }
-}
-
 PaintInvalidationReason LayoutObject::invalidatePaintIfNeeded(const PaintInvalidationState& paintInvalidationState)
 {
-    ASSERT(&paintInvalidationState.currentObject() == this);
+    DCHECK(&paintInvalidationState.currentObject() == this);
 
     if (styleRef().hasOutline()) {
         PaintLayer& layer = paintInvalidationState.paintingLayer();
         if (layer.layoutObject() != this)
             layer.setNeedsPaintPhaseDescendantOutlines();
     }
 
     LayoutView* v = view();
     if (v->document().printing())
         return PaintInvalidationNone; // Don't invalidate paints if we're printing.
 
+    PaintInvalidatorContextAdapter context(paintInvalidationState);
+
     const LayoutBoxModelObject& paintInvalidationContainer = paintInvalidationState.paintInvalidationContainer();
-    ASSERT(paintInvalidationContainer == containerForPaintInvalidation());
+    DCHECK(paintInvalidationContainer == containerForPaintInvalidation());
 
-    const LayoutRect oldBounds = previousPaintInvalidationRect();
-    const LayoutPoint oldLocation = RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled() ? LayoutPoint() : previousPositionFromPaintInvalidationBacking();
-    LayoutRect newBounds = paintInvalidationState.computePaintInvalidationRectInBacking();
-    LayoutPoint newLocation = RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled() ? LayoutPoint() : paintInvalidationState.computePositionFromPaintInvalidationBacking();
+    context.oldBounds = previousPaintInvalidationRect();
+    context.oldLocation = previousPositionFromPaintInvalidationBacking();
+    context.newBounds = paintInvalidationState.computePaintInvalidationRectInBacking();
+    context.newLocation = paintInvalidationState.computePositionFromPaintInvalidationBacking();
 
     IntSize adjustment = scrollAdjustmentForPaintInvalidation(paintInvalidationContainer);
-    newLocation.move(adjustment);
-    newBounds.move(adjustment);
+    context.newLocation.move(adjustment);
+    context.newBounds.move(adjustment);
 
-    setPreviousPaintInvalidationRect(newBounds);
-    if (!RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled())
-        setPreviousPositionFromPaintInvalidationBacking(newLocation);
+    setPreviousPaintInvalidationRect(context.newBounds);
+    setPreviousPositionFromPaintInvalidationBacking(context.newLocation);
 
     if (!shouldCheckForPaintInvalidationRegardlessOfPaintInvalidationState() && paintInvalidationState.forcedSubtreeInvalidationRectUpdateWithinContainerOnly()) {
         // We are done updating the paint invalidation rect. No other paint invalidation work to do for this object.
         return PaintInvalidationNone;
     }
 
-    PaintInvalidationReason invalidationReason = getPaintInvalidationReason(paintInvalidationState, oldBounds, oldLocation, newBounds, newLocation);
-
-    // We need to invalidate the selection before checking for whether we are doing a full invalidation.
-    // This is because we need to update the old rect regardless.
-    invalidateSelectionIfNeeded(paintInvalidationContainer, paintInvalidationState, invalidationReason);
-
-    TRACE_EVENT2(TRACE_DISABLED_BY_DEFAULT("blink.invalidation"), "LayoutObject::invalidatePaintIfNeeded()",
-        "object", this->debugName().ascii(),
-        "info", jsonObjectForOldAndNewRects(oldBounds, oldLocation, newBounds, newLocation));
-
-    bool backgroundObscured = backgroundIsKnownToBeObscured();
-    if (!isFullPaintInvalidationReason(invalidationReason) && backgroundObscured != m_bitfields.previousBackgroundObscured())
-        invalidationReason = PaintInvalidationBackgroundObscurationChange;
-    m_bitfields.setPreviousBackgroundObscured(backgroundObscured);
-
-    if (invalidationReason == PaintInvalidationNone || invalidationReason == PaintInvalidationDelayedFull) {
-        // TODO(trchen): Currently we don't keep track of paint offset of layout objects.
-        // There are corner cases that the display items need to be invalidated for paint offset
-        // mutation, but incurs no pixel difference (i.e. bounds stay the same) so no rect-based
-        // invalidation is issued. See crbug.com/508383 and crbug.com/515977.
-        // This is a workaround to force display items to update paint offset.
-        if (!RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled() && paintInvalidationState.forcedSubtreeInvalidationCheckingWithinContainer())
-            invalidateDisplayItemClientsWithPaintInvalidationState(paintInvalidationState, PaintInvalidationLocationChange);
-
-        return invalidationReason;
-    }
-
-    if (invalidationReason == PaintInvalidationIncremental)
-        incrementallyInvalidatePaint(paintInvalidationContainer, oldBounds, newBounds, newLocation);
-    else
-        fullyInvalidatePaint(paintInvalidationContainer, invalidationReason, oldBounds, newBounds);
-
-    invalidateDisplayItemClientsWithPaintInvalidationState(paintInvalidationState, invalidationReason);
-    return invalidationReason;
+    return invalidatePaintIfNeeded(context);
 }
 
-PaintInvalidationReason LayoutObject::getPaintInvalidationReason(const PaintInvalidationState& paintInvalidationState,
-    const LayoutRect& oldBounds, const LayoutPoint& oldPositionFromPaintInvalidationBacking,
-    const LayoutRect& newBounds, const LayoutPoint& newPositionFromPaintInvalidationBacking) const
+PaintInvalidationReason LayoutObject::invalidatePaintIfNeeded(const PaintInvalidatorContext& context) const
 {
-    if (paintInvalidationState.forcedSubtreeFullInvalidationWithinContainer())
-        return PaintInvalidationSubtree;
-
-    if (shouldDoFullPaintInvalidation())
-        return m_bitfields.fullPaintInvalidationReason();
-
-    if (paintedOutputOfObjectHasNoEffect())
-        return PaintInvalidationNone;
-
-    // The outline may change shape because of position change of descendants. For simplicity,
-    // just force full paint invalidation if this object is marked for checking paint invalidation
-    // for any reason.
-    if (styleRef().hasOutline())
-        return PaintInvalidationOutline;
-
-    bool locationChanged = newPositionFromPaintInvalidationBacking != oldPositionFromPaintInvalidationBacking;
-
-    // If the bounds are the same then we know that none of the statements below
-    // can match, so we can early out.
-    if (oldBounds == newBounds)
-        return locationChanged && !oldBounds.isEmpty() ? PaintInvalidationLocationChange : PaintInvalidationNone;
-
-    // If we shifted, we don't know the exact reason so we are conservative and trigger a full invalidation. Shifting could
-    // be caused by some layout property (left / top) or some in-flow layoutObject inserted / removed before us in the tree.
-    if (newBounds.location() != oldBounds.location())
-        return PaintInvalidationBoundsChange;
-
-    // If the size is zero on one of our bounds then we know we're going to have
-    // to do a full invalidation of either old bounds or new bounds. If we fall
-    // into the incremental invalidation we'll issue two invalidations instead
-    // of one.
-    if (oldBounds.isEmpty())
-        return PaintInvalidationBecameVisible;
-    if (newBounds.isEmpty())
-        return PaintInvalidationBecameInvisible;
-
-    if (locationChanged)
-        return PaintInvalidationLocationChange;
-
-    return PaintInvalidationIncremental;
+    return ObjectPaintInvalidator(*this, context).invalidatePaintIfNeeded();
 }
 
 void LayoutObject::adjustInvalidationRectForCompositedScrolling(LayoutRect& rect, const LayoutBoxModelObject& paintInvalidationContainer) const
 {
     if (compositedScrollsWithRespectTo(paintInvalidationContainer)) {
         LayoutSize offset(-toLayoutBox(&paintInvalidationContainer)->scrolledContentOffset());
         rect.move(offset);
     }
 }
 
@@ skipping 11 matching lines @@
     m_previousPaintInvalidationRect.move(LayoutSize(scrollDelta));
 }
 
 void LayoutObject::clearPreviousPaintInvalidationRects()
 {
     setPreviousPaintInvalidationRect(LayoutRect());
     // After clearing ("invalidating" the paint invalidation rects, mark this object as needing to re-compute them.
     setShouldDoFullPaintInvalidation();
 }
 
-void LayoutObject::incrementallyInvalidatePaint(const LayoutBoxModelObject& paintInvalidationContainer, const LayoutRect& oldBounds, const LayoutRect& newBounds, const LayoutPoint& positionFromPaintInvalidationBacking)
-{
-    ASSERT(oldBounds.location() == newBounds.location());
-
-    LayoutUnit deltaRight = newBounds.maxX() - oldBounds.maxX();
-    if (deltaRight > 0) {
-        LayoutRect invalidationRect(oldBounds.maxX(), newBounds.y(), deltaRight, newBounds.height());
-        invalidatePaintUsingContainer(paintInvalidationContainer, invalidationRect, PaintInvalidationIncremental);
-    } else if (deltaRight < 0) {
-        LayoutRect invalidationRect(newBounds.maxX(), oldBounds.y(), -deltaRight, oldBounds.height());
-        invalidatePaintUsingContainer(paintInvalidationContainer, invalidationRect, PaintInvalidationIncremental);
-    }
-
-    LayoutUnit deltaBottom = newBounds.maxY() - oldBounds.maxY();
-    if (deltaBottom > 0) {
-        LayoutRect invalidationRect(newBounds.x(), oldBounds.maxY(), newBounds.width(), deltaBottom);
-        invalidatePaintUsingContainer(paintInvalidationContainer, invalidationRect, PaintInvalidationIncremental);
-    } else if (deltaBottom < 0) {
-        LayoutRect invalidationRect(oldBounds.x(), newBounds.maxY(), oldBounds.width(), -deltaBottom);
-        invalidatePaintUsingContainer(paintInvalidationContainer, invalidationRect, PaintInvalidationIncremental);
-    }
-}
-
-void LayoutObject::fullyInvalidatePaint(const LayoutBoxModelObject& paintInvalidationContainer, PaintInvalidationReason invalidationReason, const LayoutRect& oldBounds, const LayoutRect& newBounds)
-{
-    // The following logic avoids invalidating twice if one set of bounds contains the other.
-    if (!newBounds.contains(oldBounds)) {
-        LayoutRect invalidationRect = oldBounds;
-        invalidatePaintUsingContainer(paintInvalidationContainer, invalidationRect, invalidationReason);
-
-        if (oldBounds.contains(newBounds))
-            return;
-    }
-
-    LayoutRect invalidationRect = newBounds;
-    invalidatePaintUsingContainer(paintInvalidationContainer, invalidationRect, invalidationReason);
-}
-
 LayoutRect LayoutObject::absoluteClippedOverflowRect() const
 {
     LayoutRect rect = localOverflowRectForPaintInvalidation();
     mapToVisualRectInAncestorSpace(view(), rect);
     return rect;
 }
 
 LayoutRect LayoutObject::localOverflowRectForPaintInvalidation() const
 {
     ASSERT_NOT_REACHED();
@@ skipping 1065 matching lines @@
     // m_style is null in cases of partial construction. Any handler we added
     // previously may have already been removed by the Document independently.
     if (node() && !node()->isTextNode() && m_style && m_style->getTouchAction() != TouchActionAuto) {
         EventHandlerRegistry& registry = document().frameHost()->eventHandlerRegistry();
         if (registry.eventHandlerTargets(EventHandlerRegistry::TouchStartOrMoveEventBlocking)->contains(node()))
             registry.didRemoveEventHandler(*node(), EventHandlerRegistry::TouchStartOrMoveEventBlocking);
     }
 
     setAncestorLineBoxDirty(false);
 
-    if (selectionPaintInvalidationMap)
-        selectionPaintInvalidationMap->remove(this);
+    ObjectPaintInvalidator::objectWillBeDestroyed(*this);
 
     if (RuntimeEnabledFeatures::slimmingPaintV2Enabled())
         objectPaintPropertiesMap().remove(this);
 
     clearLayoutRootIfNeeded();
 
     if (m_style) {
         for (const FillLayer* bgLayer = &m_style->backgroundLayers(); bgLayer; bgLayer = bgLayer->next()) {
             if (StyleImage* backgroundImage = bgLayer->image())
                 backgroundImage->removeClient(this);
@@ skipping 800 matching lines @@
 }
 
 void LayoutObject::setMayNeedPaintInvalidationAnimatgedBackgroundImage()
 {
     if (mayNeedPaintInvalidationAnimatedBackgroundImage())
         return;
     m_bitfields.setMayNeedPaintInvalidationAnimatedBackgroundImage(true);
     setMayNeedPaintInvalidation();
 }
 
-void LayoutObject::clearPaintInvalidationFlags(const PaintInvalidationState& paintInvalidationState)
+void LayoutObject::clearPaintInvalidationFlags()
 {
     // paintInvalidationStateIsDirty should be kept in sync with the
     // booleans that are cleared below.
     ASSERT(!shouldCheckForPaintInvalidationRegardlessOfPaintInvalidationState() || paintInvalidationStateIsDirty());
     clearShouldDoFullPaintInvalidation();
     m_bitfields.setChildShouldCheckForPaintInvalidation(false);
     m_bitfields.setMayNeedPaintInvalidation(false);
     m_bitfields.setMayNeedPaintInvalidationSubtree(false);
     m_bitfields.setMayNeedPaintInvalidationAnimatedBackgroundImage(false);
     m_bitfields.setShouldInvalidateSelection(false);
@@ skipping 213 matching lines @@
         const blink::LayoutObject* root = object1;
         while (root->parent())
             root = root->parent();
         root->showLayoutTreeAndMark(object1, "*", object2, "-", 0);
     } else {
         WTFLogAlways("%s", "Cannot showLayoutTree. Root is (nil)");
     }
 }
 
 #endif