WIP: Reset paint invalidation at transform boundaries.

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

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/layout/PaintInvalidationState.h"
 
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/layout/LayoutInline.h"
 #include "core/layout/LayoutPart.h"
 #include "core/layout/LayoutView.h"
 #include "core/layout/svg/LayoutSVGRoot.h"
 #include "core/layout/svg/SVGLayoutSupport.h"
 #include "core/paint/PaintLayer.h"
 
 namespace blink {
 
 static bool supportsCachedOffsets(const LayoutObject& object)
 {
-    return !object.hasTransformRelatedProperty()
-        && !object.hasReflection()
+    return !object.hasReflection()
         && !object.hasFilterInducingProperty()
         && !object.isLayoutFlowThread()
         && !object.isLayoutMultiColumnSpannerPlaceholder()
         && !object.styleRef().isFlippedBlocksWritingMode()
         && !(object.isLayoutBlock() && object.isSVG());
 }
 
 PaintInvalidationState::PaintInvalidationState(const LayoutView& layoutView, Vector<LayoutObject*>& pendingDelayedPaintInvalidations)
     : m_currentObject(layoutView)
     , m_forcedSubtreeInvalidationFlags(0)
     , m_clipped(false)
     , m_clippedForAbsolutePosition(false)
     , m_cachedOffsetsEnabled(true)
     , m_cachedOffsetsForAbsolutePositionEnabled(true)
     , m_paintInvalidationContainer(&layoutView.containerForPaintInvalidation())
+    , m_realPaintInvalidationContainer(m_paintInvalidationContainer)
     , m_paintInvalidationContainerForStackedContents(m_paintInvalidationContainer)
+    , m_realPaintInvalidationContainerForStackedContents(m_paintInvalidationContainer)
     , m_containerForAbsolutePosition(layoutView)
     , m_pendingDelayedPaintInvalidations(pendingDelayedPaintInvalidations)
     , m_paintingLayer(*layoutView.layer())
+    , m_transformParent(nullptr)
+    , m_parentPaintInvalidationState(nullptr)
 #if ENABLE(ASSERT)
     , m_didUpdateForChildren(false)
 #endif
 #ifdef CHECK_FAST_PATH_SLOW_PATH_EQUALITY
     , m_canCheckFastPathSlowPathEquality(layoutView == m_paintInvalidationContainer)
 #endif
 {
     if (!supportsCachedOffsets(layoutView)) {
         m_cachedOffsetsEnabled = false;
+        LOG(ERROR) << "set to false";
         return;
     }
 
     FloatPoint point = layoutView.localToAncestorPoint(FloatPoint(), m_paintInvalidationContainer, TraverseDocumentBoundaries | InputIsInFrameCoordinates);
     m_paintOffset = LayoutSize(point.x(), point.y());
     m_paintOffsetForAbsolutePosition = m_paintOffset;
 }
 
 PaintInvalidationState::PaintInvalidationState(const PaintInvalidationState& parentState, const LayoutObject& currentObject)
     : m_currentObject(currentObject)
     , m_forcedSubtreeInvalidationFlags(parentState.m_forcedSubtreeInvalidationFlags)
     , m_clipped(parentState.m_clipped)
     , m_clippedForAbsolutePosition(parentState.m_clippedForAbsolutePosition)
     , m_clipRect(parentState.m_clipRect)
     , m_clipRectForAbsolutePosition(parentState.m_clipRectForAbsolutePosition)
     , m_paintOffset(parentState.m_paintOffset)
     , m_paintOffsetForAbsolutePosition(parentState.m_paintOffsetForAbsolutePosition)
     , m_cachedOffsetsEnabled(parentState.m_cachedOffsetsEnabled)
     , m_cachedOffsetsForAbsolutePositionEnabled(parentState.m_cachedOffsetsForAbsolutePositionEnabled)
     , m_paintInvalidationContainer(parentState.m_paintInvalidationContainer)
+    , m_realPaintInvalidationContainer(parentState.m_realPaintInvalidationContainer)
     , m_paintInvalidationContainerForStackedContents(parentState.m_paintInvalidationContainerForStackedContents)
+    , m_realPaintInvalidationContainerForStackedContents(parentState.m_realPaintInvalidationContainerForStackedContents)
     , m_containerForAbsolutePosition(currentObject.canContainAbsolutePositionObjects() ? currentObject : parentState.m_containerForAbsolutePosition)
     , m_svgTransform(parentState.m_svgTransform)
     , m_pendingDelayedPaintInvalidations(parentState.pendingDelayedPaintInvalidationTargets())
     , m_paintingLayer(currentObject.hasLayer() && toLayoutBoxModelObject(currentObject).hasSelfPaintingLayer() ? *toLayoutBoxModelObject(currentObject).layer() : parentState.m_paintingLayer)
+    , m_transformParent(parentState.m_transformParent)
+    , m_parentPaintInvalidationState(nullptr)
 #if ENABLE(ASSERT)
     , m_didUpdateForChildren(false)
 #endif
 #ifdef CHECK_FAST_PATH_SLOW_PATH_EQUALITY
     , m_canCheckFastPathSlowPathEquality(parentState.m_canCheckFastPathSlowPathEquality)
 #endif
 {
+    if (parentState.m_currentObject.styleRef().hasTransform()) {
+        m_transformParent = &parentState;
+    }
+
     ASSERT(&m_paintingLayer == currentObject.paintingLayer());
 
     if (currentObject == parentState.m_currentObject) {
         // Sometimes we create a new PaintInvalidationState from parentState on the same object
         // (e.g. LayoutView, and the HorriblySlowRectMapping cases in LayoutBlock::invalidatePaintOfSubtreesIfNeeded()).
         // TODO(wangxianzhu): Avoid this for RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled().
 #if ENABLE(ASSERT)
         m_didUpdateForChildren = parentState.m_didUpdateForChildren;
 #endif
         return;
     }
 
     ASSERT(parentState.m_didUpdateForChildren);
 
-    if (currentObject.isPaintInvalidationContainer()) {
+    if (currentObject.isPaintInvalidationContainer() || (currentObject.isBox() && currentObject.styleRef().hasTransform())) {
         m_paintInvalidationContainer = toLayoutBoxModelObject(&currentObject);
         if (currentObject.styleRef().isStackingContext())
-            m_paintInvalidationContainerForStackedContents = toLayoutBoxModelObject(&currentObject);
+            m_paintInvalidationContainerForStackedContents = m_paintInvalidationContainer;
+
+        if (currentObject.isPaintInvalidationContainer()) {
+            m_realPaintInvalidationContainer = toLayoutBoxModelObject(&currentObject);
+            if (currentObject.styleRef().isStackingContext())
+                m_realPaintInvalidationContainerForStackedContents = toLayoutBoxModelObject(&currentObject);
+        } else {
+            m_parentPaintInvalidationState = &parentState;
+        }
     } else if (currentObject.isLayoutView()) {
         // m_paintInvalidationContainerForStackedContents is only for stacked descendants in its own frame,
         // because it doesn't establish stacking context for stacked contents in sub-frames.
         // Contents stacked in the root stacking context in this frame should use this frame's paintInvalidationContainer.
+        m_realPaintInvalidationContainerForStackedContents = m_realPaintInvalidationContainer;
         m_paintInvalidationContainerForStackedContents = m_paintInvalidationContainer;
     } else if (currentObject.styleRef().isStacked()
         // This is to exclude some objects (e.g. LayoutText) inheriting stacked style from parent but aren't actually stacked.
         && currentObject.hasLayer()
         && m_paintInvalidationContainer != m_paintInvalidationContainerForStackedContents) {
         // The current object is stacked, so we should use m_paintInvalidationContainerForStackedContents as its
         // paint invalidation container on which the current object is painted.
         m_paintInvalidationContainer = m_paintInvalidationContainerForStackedContents;
+        m_realPaintInvalidationContainer = m_realPaintInvalidationContainerForStackedContents;
         // We are changing paintInvalidationContainer to m_paintInvalidationContainerForStackedContents. Must disable
         // cached offsets because we didn't track paint offset from m_paintInvalidationContainerForStackedContents.
         // TODO(wangxianzhu): There are optimization opportunities:
         // - Like what we do for fixed-position, calculate the paint offset in slow path and enable fast path for
         //   descendants if possible; or
         // - Track offset between the two paintInvalidationContainers.
         m_cachedOffsetsEnabled = false;
         if (m_forcedSubtreeInvalidationFlags & FullInvalidationForStackedContents)
             m_forcedSubtreeInvalidationFlags |= FullInvalidation;
     }
@@ skipping 68 matching lines @@
 
     EPosition position = m_currentObject.styleRef().position();
 
     if (position == FixedPosition) {
         if (m_paintInvalidationContainer != m_currentObject.view() && m_paintInvalidationContainer->view() == m_currentObject.view()) {
             // TODO(crbug.com/598762): localToAncestorPoint() is incorrect for fixed-position when paintInvalidationContainer
             // is under the containing LayoutView.
             m_cachedOffsetsEnabled = false;
             return;
         }
+        // Does this still work correctly??
         // Use slow path to get the offset of the fixed-position, and enable fast path for descendants.
         FloatPoint fixedOffset = m_currentObject.localToAncestorPoint(FloatPoint(), m_paintInvalidationContainer, TraverseDocumentBoundaries);
         m_paintOffset = LayoutSize(fixedOffset.x(), fixedOffset.y());
         // In the above way to get paint offset, we can't get accurate clip rect, so just assume no clip.
         // Clip on fixed-position is rare, in case that paintInvalidationContainer crosses frame boundary
         // and the LayoutView is clipped by something in owner document.
         if (m_clipped) {
             m_clipped = false;
 #ifdef CHECK_FAST_PATH_SLOW_PATH_EQUALITY
             m_canCheckFastPathSlowPathEquality = false;
@@ skipping 69 matching lines @@
 void PaintInvalidationState::updateForNormalChildren()
 {
     if (!m_cachedOffsetsEnabled)
         return;
 
     if (!m_currentObject.isBoxModelObject() && !m_currentObject.isSVG())
         return;
 
     if (m_currentObject.isLayoutView()) {
         if (!m_currentObject.document().settings() || !m_currentObject.document().settings()->rootLayerScrolls()) {
-            if (m_currentObject != m_paintInvalidationContainer) {
+            if (m_currentObject != m_realPaintInvalidationContainer) {
                 m_paintOffset -= toLayoutView(m_currentObject).frameView()->scrollOffset();
                 addClipRectRelativeToPaintOffset(toLayoutView(m_currentObject).viewRect());
             }
             return;
         }
     } else if (m_currentObject.isSVGRoot()) {
         const LayoutSVGRoot& svgRoot = toLayoutSVGRoot(m_currentObject);
         if (svgRoot.shouldApplyViewportClip())
             addClipRectRelativeToPaintOffset(LayoutRect(LayoutPoint(), LayoutSize(svgRoot.pixelSnappedSize())));
     } else if (m_currentObject.isTableRow()) {
         // Child table cell's locationOffset() includes its row's locationOffset().
         m_paintOffset -= toLayoutBox(m_currentObject).locationOffset();
     }
 
     if (!m_currentObject.hasOverflowClip())
         return;
 
     const LayoutBox& box = toLayoutBox(m_currentObject);
 
     // Do not clip scroll layer contents because the compositor expects the whole layer
     // to be always invalidated in-time.
-    if (box == m_paintInvalidationContainer && box.scrollsOverflow())
+    if (box == m_realPaintInvalidationContainer && box.scrollsOverflow())
         ASSERT(!m_clipped); // The box establishes paint invalidation container, so no m_clipped inherited.
     else
         addClipRectRelativeToPaintOffset(box.overflowClipRect(LayoutPoint()));
 
     m_paintOffset -= box.scrolledContentOffset();
 
     // FIXME: <http://bugs.webkit.org/show_bug.cgi?id=13443> Apply control clip if present.
 }
 
 static FloatPoint slowLocalToAncestorPoint(const LayoutObject& object, const LayoutBoxModelObject& ancestor, const FloatPoint& point)
@@ skipping 67 matching lines @@
 static void slowMapToVisualRectInAncestorSpace(const LayoutObject& object, const LayoutBoxModelObject& ancestor, LayoutRect& rect)
 {
     if (object.isLayoutView())
         toLayoutView(object).mapToVisualRectInAncestorSpace(&ancestor, rect, InputIsInFrameCoordinates, DefaultVisualRectFlags);
     else
         object.mapToVisualRectInAncestorSpace(&ancestor, rect);
 }
 
 void PaintInvalidationState::mapLocalRectToPaintInvalidationContainer(LayoutRect& rect) const
 {
-    ASSERT(!m_didUpdateForChildren);
-
     if (m_cachedOffsetsEnabled) {
 #ifdef CHECK_FAST_PATH_SLOW_PATH_EQUALITY
         LayoutRect slowPathRect(rect);
-        slowMapToVisualRectInAncestorSpace(m_currentObject, *m_paintInvalidationContainer, slowPathRect);
+        slowMapToVisualRectInAncestorSpace(m_currentObject, *m_realPaintInvalidationContainer, slowPathRect);
 #endif
         rect.move(m_paintOffset);
         if (m_clipped)
             rect.intersect(m_clipRect);
+
+        if (m_parentPaintInvalidationState) {
+            if (m_currentObject.container()) {
+                RELEASE_ASSERT(m_currentObject.container()->isBoxModelObject());
+                LayoutBoxModelObject* box = toLayoutBoxModelObject(m_currentObject.container());
+                m_currentObject.mapToVisualRectInAncestorSpace(box, rect);
+            }
+
+            m_parentPaintInvalidationState->mapLocalRectToPaintInvalidationContainer(rect);
+        } else if (m_transformParent) {
+            m_transformParent->mapLocalRectToPaintInvalidationContainer(rect);
+        }
+
 #ifdef CHECK_FAST_PATH_SLOW_PATH_EQUALITY
         assertFastPathAndSlowPathRectsEqual(rect, slowPathRect);
 #endif
     } else {
-        slowMapToVisualRectInAncestorSpace(m_currentObject, *m_paintInvalidationContainer, rect);
+        slowMapToVisualRectInAncestorSpace(m_currentObject, *m_realPaintInvalidationContainer, rect);
     }
 }
 
 void PaintInvalidationState::mapLocalRectToPaintInvalidationBacking(LayoutRect& rect) const
 {
     mapLocalRectToPaintInvalidationContainer(rect);
 
     if (m_paintInvalidationContainer->layer()->groupedMapping())
-        PaintLayer::mapRectInPaintInvalidationContainerToBacking(*m_paintInvalidationContainer, rect);
+        PaintLayer::mapRectInPaintInvalidationContainerToBacking(*m_realPaintInvalidationContainer, rect);
 }
 
 void PaintInvalidationState::addClipRectRelativeToPaintOffset(const LayoutRect& localClipRect)
 {
     LayoutRect clipRect = localClipRect;
     clipRect.move(m_paintOffset);
     if (m_clipped) {
         m_clipRect.intersect(clipRect);
     } else {
         m_clipRect = clipRect;
@@ skipping 53 matching lines @@
     WTFLogAlways("Fast path paint invalidation rect differs from slow path: fast: %s vs slow: %s",
         fastPathRect.toString().ascii().data(), slowPathRect.toString().ascii().data());
     showLayoutTree(&m_currentObject);
 
     ASSERT_NOT_REACHED();
 }
 
 #endif // CHECK_FAST_PATH_SLOW_PATH_EQUALITY
 
 } // namespace blink