(WIP) Invalidation during painting (for synchronized painting)

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 55 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/compositing/PaintLayerCompositor.h"
 #include "core/page/AutoscrollController.h"
 #include "core/page/Page.h"
+#include "core/paint/LineBoxListPainter.h"
 #include "core/paint/ObjectPaintProperties.h"
 #include "core/paint/ObjectPainter.h"
 #include "core/paint/PaintInfo.h"
 #include "core/paint/PaintLayer.h"
 #include "core/style/ContentData.h"
 #include "core/style/ShadowList.h"
 #include "platform/HostWindow.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/TraceEvent.h"
 #include "platform/TracedValue.h"
@@ skipping 161 matching lines @@
     , m_node(node)
     , m_parent(nullptr)
     , m_previous(nullptr)
     , m_next(nullptr)
 #if ENABLE(ASSERT)
     , m_hasAXObject(false)
     , m_setNeedsLayoutForbidden(false)
 #endif
     , m_bitfields(node)
 {
-    // TODO(wangxianzhu): Move this into initialization list when we enable the feature by default.
-    if (RuntimeEnabledFeatures::slimmingPaintOffsetCachingEnabled())
-        m_previousPositionFromPaintInvalidationBacking = uninitializedPaintOffset();
-
 #ifndef NDEBUG
     layoutObjectCounter().increment();
 #endif
     InstanceCounters::incrementCounter(InstanceCounters::LayoutObjectCounter);
 }
 
 LayoutObject::~LayoutObject()
 {
     ASSERT(!m_hasAXObject);
 #ifndef NDEBUG
@@ skipping 1142 matching lines @@
         PaintLayer& layer = paintInvalidationState.enclosingSelfPaintingLayer(*this);
         if (layer.layoutObject() != this)
             layer.setNeedsPaintPhaseDescendantOutlines();
     }
 
     LayoutView* v = view();
     if (v->document().printing())
         return PaintInvalidationNone; // Don't invalidate paints if we're printing.
 
     const LayoutRect oldBounds = previousPaintInvalidationRect();
-    const LayoutPoint oldLocation = RuntimeEnabledFeatures::slimmingPaintOffsetCachingEnabled() ? LayoutPoint() : previousPositionFromPaintInvalidationBacking();
+    const LayoutPoint oldLocation = RuntimeEnabledFeatures::slimmingPaintV2Enabled() ? LayoutPoint() : previousPositionFromPaintInvalidationBacking();
     LayoutRect newBounds = boundsRectForPaintInvalidation(paintInvalidationContainer, &paintInvalidationState);
-    LayoutPoint newLocation = RuntimeEnabledFeatures::slimmingPaintOffsetCachingEnabled() ? LayoutPoint() : PaintLayer::positionFromPaintInvalidationBacking(this, &paintInvalidationContainer, &paintInvalidationState);
+    LayoutPoint newLocation = RuntimeEnabledFeatures::slimmingPaintV2Enabled() ? LayoutPoint() : PaintLayer::positionFromPaintInvalidationBacking(this, &paintInvalidationContainer, &paintInvalidationState);
 
     // Composited scrolling should not be included in the bounds and position tracking, because the graphics layer backing the scroller
     // does not move on scroll.
     if (paintInvalidationContainer.usesCompositedScrolling() && &paintInvalidationContainer != this) {
         LayoutSize inverseOffset(toLayoutBox(&paintInvalidationContainer)->scrolledContentOffset());
         newLocation.move(inverseOffset);
         newBounds.move(inverseOffset);
     }
 
     setPreviousPaintInvalidationRect(newBounds);
-    if (!RuntimeEnabledFeatures::slimmingPaintOffsetCachingEnabled())
+    if (!RuntimeEnabledFeatures::slimmingPaintV2Enabled())
         setPreviousPositionFromPaintInvalidationBacking(newLocation);
 
     if (!shouldCheckForPaintInvalidationRegardlessOfPaintInvalidationState() && !paintInvalidationState.forcedSubtreeInvalidationWithinContainer()) {
-        ASSERT(paintInvalidationState.forcedSubtreeInvalidationRectUpdateWithinContainer());
+        ASSERT(RuntimeEnabledFeatures::slimmingPaintV2Enabled()
+            || paintInvalidationState.forcedSubtreeInvalidationRectUpdateWithinContainer());
         return PaintInvalidationNone;
     }
 
     PaintInvalidationReason invalidationReason = paintInvalidationReason(paintInvalidationContainer, 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 boxDecorationBackgroundObscured = boxDecorationBackgroundIsKnownToBeObscured();
     if (!isFullPaintInvalidationReason(invalidationReason) && boxDecorationBackgroundObscured != m_bitfields.lastBoxDecorationBackgroundObscured())
         invalidationReason = PaintInvalidationBackgroundObscurationChange;
     m_bitfields.setLastBoxDecorationBackgroundObscured(boxDecorationBackgroundObscured);
 
     if (invalidationReason == PaintInvalidationNone) {
         // 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::slimmingPaintOffsetCachingEnabled() && paintInvalidationState.forcedSubtreeInvalidationWithinContainer())
+        if (!RuntimeEnabledFeatures::slimmingPaintV2Enabled() && paintInvalidationState.forcedSubtreeInvalidationWithinContainer())
             invalidateDisplayItemClientsWithPaintInvalidationState(paintInvalidationContainer, paintInvalidationState, invalidationReason);
 
         return invalidationReason;
     }
 
     invalidateDisplayItemClientsWithPaintInvalidationState(paintInvalidationContainer, paintInvalidationState, invalidationReason);
 
     if (invalidationReason == PaintInvalidationIncremental) {
         incrementallyInvalidatePaint(paintInvalidationContainer, oldBounds, newBounds, newLocation);
         return invalidationReason;
     }
 
     fullyInvalidatePaint(paintInvalidationContainer, invalidationReason, oldBounds, newBounds);
 
     return invalidationReason;
 }
 
+void LayoutObject::invalidatePaintIfNeededForSlimmingPaintV2(const PaintInfo& paintInfo, const LayoutPoint& paintOffset)
+{
+    ASSERT(RuntimeEnabledFeatures::slimmingPaintV2Enabled());
+
+    PaintController& paintController = paintInfo.context->paintController();
+
+    // In some cases, the caller doesn't have enough information to create paintInvalidationState.
+    if (!paintInfo.paintInvalidationState) {
+        WTFLogAlways("No paint invalidation state for: %s\n", debugName().ascii().data());
+        // TODO(wangxianzhu): What to do?
+        return;
+    }
+
+    PaintInvalidationState& paintInvalidationState = *paintInfo.paintInvalidationState;
+
+    const LayoutBoxModelObject& paintInvalidationContainer = paintInvalidationState.paintInvalidationContainer();
+
+    if (!paintController.skippingCache() && paintOffsetChanged(paintOffset)) {
+        m_bitfields.setFullPaintInvalidationReason(PaintInvalidationLocationChange);
+        setPreviousPaintOffset(paintOffset);
+        if (isLayoutInline() || (isLayoutBlock() && toLayoutBlock(this)->childrenInline())) {
+            const LineBoxList& lineBoxList = isLayoutInline() ? *toLayoutInline(this)->lineBoxes() : *toLayoutBlock(this)->lineBoxes();
+            LineBoxListPainter(lineBoxList).invalidateLineBoxPaintOffsets(*this, paintInfo);
+        }
+    }
+
+    // Set paintInvalidationState's paint offset to that of the parent of this LayoutObject, to let
+    // invalidatePaintIfNeeded() and boundsRectForPaintInvalidation() work for this LayoutObject.
+    LayoutSize layerPaintOffset = paintInvalidationState.paintOffset();
+    bool originalCachedOffsetsEnabled = paintInvalidationState.cachedOffsetsEnabled();
+    if (paintController.skippingCache()) {
+        paintInvalidationState.setCachedOffsetsEnabled(false);
+    } else if (paintInvalidationState.cachedOffsetsEnabled()) {
+        // The legacy paint invalidation code expects that the paint offset in PaintInvalidationState
+        // is that of the container of the current object.
+        LayoutPoint containerPaintOffset = paintOffset + layerPaintOffset;
+        if (isBox())
+            containerPaintOffset.moveBy(-toLayoutBox(this)->location());
+        if (styleRef().hasInFlowPosition() && hasLayer())
+            containerPaintOffset.move(-toLayoutBoxModelObject(this)->layer()->offsetForInFlowPosition());
+        paintInvalidationState.setPaintOffset(toSize(containerPaintOffset));
+    }
+
+    PaintInvalidationReason reason = invalidatePaintIfNeeded(paintInvalidationState, paintInvalidationContainer);
+    clearPaintInvalidationState(paintInvalidationState);
+
+    // Restore our own values after calling legacy paint invalidation code.
+    if (paintController.skippingCache())
+        paintInvalidationState.setCachedOffsetsEnabled(originalCachedOffsetsEnabled);
+    paintInvalidationState.setPaintOffset(layerPaintOffset);
+
+    if (reason == PaintInvalidationDelayedFull)
+        setShouldDoFullPaintInvalidation(PaintInvalidationFull);
+}
+
 PaintInvalidationReason LayoutObject::paintInvalidationReason(const LayoutBoxModelObject& paintInvalidationContainer,
     const LayoutRect& oldBounds, const LayoutPoint& oldPositionFromPaintInvalidationBacking,
     const LayoutRect& newBounds, const LayoutPoint& newPositionFromPaintInvalidationBacking) const
 {
     // First check for InvalidationLocationChange to avoid it from being hidden by other
     // invalidation reasons because we'll need to force check for paint invalidation for
     // children when location of this object changed.
     if (newPositionFromPaintInvalidationBacking != oldPositionFromPaintInvalidationBacking)
         return PaintInvalidationLocationChange;
 
@@ skipping 1901 matching lines @@
     m_bitfields.setShouldInvalidateSelection(true);
     markContainerChainForPaintInvalidation();
     frameView()->scheduleVisualUpdateForPaintInvalidationIfNeeded();
 }
 
 void LayoutObject::setShouldDoFullPaintInvalidation(PaintInvalidationReason reason)
 {
     // Only full invalidation reasons are allowed.
     ASSERT(isFullPaintInvalidationReason(reason));
 
+    // TODO(wangxianzhu): This is temporary for table column rect-based paint invalidation in synchronized painting mode.
+    // We won't paint table columns during synchronized painting so won't call their invalidatePaintIfNeeded().
+    // Delegate their style-caused paint invalidation to their table just like their invalidatePaintIfNeeded does.
+    // Remove this when we remove rect-based paint invalidation.
+    if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
+        if (isLayoutTableCol())
+            toLayoutTableCol(this)->table()->setShouldDoFullPaintInvalidation(reason);
+    }
+
     bool isUpgradingDelayedFullToFull = m_bitfields.fullPaintInvalidationReason() == PaintInvalidationDelayedFull && reason != PaintInvalidationDelayedFull;
 
     if (m_bitfields.fullPaintInvalidationReason() == PaintInvalidationNone || isUpgradingDelayedFullToFull) {
         if (reason == PaintInvalidationFull)
             reason = documentLifecycleBasedPaintInvalidationReason(document().lifecycle());
         m_bitfields.setFullPaintInvalidationReason(reason);
         if (!isUpgradingDelayedFullToFull)
             markContainerChainForPaintInvalidation();
     }
 
     frameView()->scheduleVisualUpdateForPaintInvalidationIfNeeded();
 }
 
 void LayoutObject::setMayNeedPaintInvalidation()
 {
     if (mayNeedPaintInvalidation())
         return;
     m_bitfields.setMayNeedPaintInvalidation(true);
     markContainerChainForPaintInvalidation();
     frameView()->scheduleVisualUpdateForPaintInvalidationIfNeeded();
 }
 
 void LayoutObject::clearPaintInvalidationState(const PaintInvalidationState& paintInvalidationState)
 {
     // paintInvalidationStateIsDirty should be kept in sync with the
     // booleans that are cleared below.
-    ASSERT(paintInvalidationState.forcedSubtreeInvalidationWithinContainer() || paintInvalidationState.forcedSubtreeInvalidationRectUpdateWithinContainer() || paintInvalidationStateIsDirty());
+    ASSERT(RuntimeEnabledFeatures::slimmingPaintV2Enabled()
+        || paintInvalidationState.forcedSubtreeInvalidationWithinContainer()
+        || paintInvalidationState.forcedSubtreeInvalidationRectUpdateWithinContainer()
+        || paintInvalidationStateIsDirty());
     clearShouldDoFullPaintInvalidation();
     m_bitfields.setChildShouldCheckForPaintInvalidation(false);
     m_bitfields.setNeededLayoutBecauseOfChildren(false);
     m_bitfields.setShouldInvalidateOverflowForPaint(false);
     m_bitfields.setMayNeedPaintInvalidation(false);
     m_bitfields.setShouldInvalidateSelection(false);
 }
 
 bool LayoutObject::isAllowedToModifyLayoutTreeStructure(Document& document)
 {
@@ skipping 225 matching lines @@
         const blink::LayoutObject* root = object1;
         while (root->parent())
             root = root->parent();
         root->showLayoutTreeAndMark(object1, "*", object2, "-", 0);
     } else {
         fprintf(stderr, "Cannot showLayoutTree. Root is (nil)\n");
     }
 }
 
 #endif