Remove ForceHorriblySlowRectMapping

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/Settings.h"
 #include "core/layout/LayoutInline.h"
 #include "core/layout/LayoutPart.h"
 #include "core/layout/LayoutView.h"
 #include "core/layout/svg/LayoutSVGModelObject.h"
 #include "core/layout/svg/LayoutSVGRoot.h"
 #include "core/layout/svg/SVGLayoutSupport.h"
 #include "core/paint/PaintLayer.h"
 
 // We can't enable this by default because saturated operations of LayoutUnit
 // don't conform commutative law for overflowing results, preventing us from
 // making fast-path and slow-path always return the same result.
 #define ASSERT_SAME_RESULT_SLOW_AND_FAST_PATH (0 && ENABLE(ASSERT))
 
 namespace blink {
 
-static bool isAbsolutePositionUnderRelativePositionInline(const LayoutObject& object)
-{
-    if (object.styleRef().position() != AbsolutePosition)
-        return false;
-    if (LayoutObject* container = object.container())
-        return container->isAnonymousBlock() && container->styleRef().position() == RelativePosition;
-    return false;
-}
-
 static bool supportsCachedOffsets(const LayoutObject& object)
 {
-    // TODO(wangxianzhu): Move some conditions to fast path if possible.
     return !object.hasTransformRelatedProperty()
         && !object.hasReflection()
         && !object.hasFilter()
         && !object.isLayoutFlowThread()
         && !object.isLayoutMultiColumnSpannerPlaceholder()
-        && object.styleRef().position() != FixedPosition
         && !object.styleRef().isFlippedBlocksWritingMode()
-        // TODO(crbug.com/598094): Handle this in fast path.
-        && !isAbsolutePositionUnderRelativePositionInline(object);
+        && !(object.isLayoutBlock() && object.isSVG());
 }
 
 PaintInvalidationState::PaintInvalidationState(const LayoutView& layoutView, Vector<LayoutObject*>& pendingDelayedPaintInvalidations)
     : m_currentObject(layoutView)
-    , m_clipped(false)
-    , m_cachedOffsetsEnabled(true)
     , m_forcedSubtreeInvalidationWithinContainer(false)
     , m_forcedSubtreeInvalidationRectUpdateWithinContainer(false)
-    , m_paintInvalidationContainer(layoutView.containerForPaintInvalidation())
+    , m_clipped(false)
+    , m_clippedForAbsolutePosition(false)
+    , m_cachedOffsetsEnabled(true)
+    , m_cachedOffsetsForAbsolutePositionEnabled(true)
+    , m_paintInvalidationContainer(&layoutView.containerForPaintInvalidation())
+    , m_paintInvalidationContainerForStackedContents(m_paintInvalidationContainer)
+    , m_containerForAbsolutePosition(layoutView)
     , m_pendingDelayedPaintInvalidations(pendingDelayedPaintInvalidations)
     , m_enclosingSelfPaintingLayer(*layoutView.layer())
 #if ENABLE(ASSERT)
     , m_didUpdateForChildren(false)
 #endif
 {
     if (!supportsCachedOffsets(layoutView)) {
         m_cachedOffsetsEnabled = false;
         return;
     }
 
-    FloatPoint point = layoutView.localToAncestorPoint(FloatPoint(), &m_paintInvalidationContainer, TraverseDocumentBoundaries | InputIsInFrameCoordinates);
+    FloatPoint point = layoutView.localToAncestorPoint(FloatPoint(), m_paintInvalidationContainer, TraverseDocumentBoundaries | InputIsInFrameCoordinates);
     m_paintOffset = LayoutSize(point.x(), point.y());
-}
-
-// TODO(wangxianzhu): This is temporary for positioned object whose paintInvalidationContainer is different from
-// the one we find during tree walk. Remove this after we fix the issue with tree walk in DOM-order.
-PaintInvalidationState::PaintInvalidationState(const PaintInvalidationState& parentState, const LayoutBoxModelObject& currentObject, const LayoutBoxModelObject& paintInvalidationContainer)
-    : m_currentObject(currentObject)
-    , m_clipped(parentState.m_clipped)
-    , m_cachedOffsetsEnabled(parentState.m_cachedOffsetsEnabled)
-    , m_forcedSubtreeInvalidationWithinContainer(parentState.m_forcedSubtreeInvalidationWithinContainer)
-    , m_forcedSubtreeInvalidationRectUpdateWithinContainer(parentState.m_forcedSubtreeInvalidationRectUpdateWithinContainer)
-    , m_clipRect(parentState.m_clipRect)
-    , m_paintOffset(parentState.m_paintOffset)
-    , m_paintInvalidationContainer(paintInvalidationContainer)
-    , m_svgTransform(parentState.m_svgTransform)
-    , m_pendingDelayedPaintInvalidations(parentState.pendingDelayedPaintInvalidationTargets())
-    , m_enclosingSelfPaintingLayer(parentState.enclosingSelfPaintingLayer(currentObject))
-#if ENABLE(ASSERT)
-    , m_didUpdateForChildren(true)
-#endif
-{
-    ASSERT(parentState.m_didUpdateForChildren);
-    ASSERT(!m_cachedOffsetsEnabled);
+    m_paintOffsetForAbsolutePosition = m_paintOffset;
 }
 
 PaintInvalidationState::PaintInvalidationState(const PaintInvalidationState& parentState, const LayoutObject& currentObject)
     : m_currentObject(currentObject)
-    , m_clipped(parentState.m_clipped)
-    , m_cachedOffsetsEnabled(parentState.m_cachedOffsetsEnabled)
     , m_forcedSubtreeInvalidationWithinContainer(parentState.m_forcedSubtreeInvalidationWithinContainer)
     , m_forcedSubtreeInvalidationRectUpdateWithinContainer(parentState.m_forcedSubtreeInvalidationRectUpdateWithinContainer)
+    , 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_paintInvalidationContainer(currentObject.isPaintInvalidationContainer() ? toLayoutBoxModelObject(currentObject) : parentState.m_paintInvalidationContainer)
+    , m_paintOffsetForAbsolutePosition(parentState.m_paintOffsetForAbsolutePosition)
+    , m_cachedOffsetsEnabled(parentState.m_cachedOffsetsEnabled)
+    , m_cachedOffsetsForAbsolutePositionEnabled(parentState.m_cachedOffsetsForAbsolutePositionEnabled)
+    , m_paintInvalidationContainer(parentState.m_paintInvalidationContainer)
+    , m_paintInvalidationContainerForStackedContents(parentState.m_paintInvalidationContainerForStackedContents)
+    , m_containerForAbsolutePosition(currentObject.canContainAbsolutePositionObjects() ? currentObject : parentState.m_containerForAbsolutePosition)
     , m_svgTransform(parentState.m_svgTransform)
     , m_pendingDelayedPaintInvalidations(parentState.pendingDelayedPaintInvalidationTargets())
     , m_enclosingSelfPaintingLayer(parentState.enclosingSelfPaintingLayer(currentObject))
 #if ENABLE(ASSERT)
     , m_didUpdateForChildren(false)
 #endif
 {
     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);
 
+    EPosition position = currentObject.styleRef().position();
+
+    if (currentObject.isPaintInvalidationContainer()) {
+        m_paintInvalidationContainer = toLayoutBoxModelObject(&currentObject);
+        if (currentObject.styleRef().isStackingContext()) {
+            m_paintInvalidationContainerForStackedContents = toLayoutBoxModelObject(&currentObject);
+
+            // Disable cached offsets for absolute-position objects if this object is not a container for
+            // absolute-position because absolute-position objects' locations are determined by something
+            // above their paint invalidation container.
+            if (m_currentObject != m_containerForAbsolutePosition)

[chrishtr, 2016/03/31 22:32:11]

Can this slow path be avoided by adjusting m_paintOffsetForAbsolutePosition to
be relative to
the current stacking context? Is that just subtracting m_paintOffset from it?

[Xianzhu, 2016/04/01 16:07:56]

Good idea. Done.

+                m_cachedOffsetsForAbsolutePositionEnabled = false;
+        }
+    } 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_paintInvalidationContainerForStackedContents = m_paintInvalidationContainer;

[chrishtr, 2016/03/31 22:32:11]

Does the m_cachedOffsetsForAbsolutePositionEnabled = false slow path from above
also apply here?

[Xianzhu, 2016/04/01 16:07:56]

No, because LayoutView resets both stacking context and containing block for
absolute-position objects.

+    } 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;
+        // We are changing paintInvalidationContainer to m_paintInvalidationContainerForStackedContents. Must disable
+        // cached offsets because we didn't track paint offset from m_paintInvalidationContainerForStackedContents.
+        m_cachedOffsetsEnabled = false;
+    }
+
     if (!currentObject.isBoxModelObject() && !currentObject.isSVG())
         return;
 
-    if (m_cachedOffsetsEnabled && !supportsCachedOffsets(currentObject))
-        m_cachedOffsetsEnabled = false;
+    if (m_cachedOffsetsEnabled || currentObject == m_paintInvalidationContainer)
+        m_cachedOffsetsEnabled = supportsCachedOffsets(currentObject);
 
     if (currentObject.isSVG()) {
         if (currentObject.isSVGRoot()) {
             m_svgTransform = toLayoutSVGRoot(currentObject).localToBorderBoxTransform();
             // Don't early return here, because the SVGRoot object needs to execute the later code
             // as a normal LayoutBox.
         } else {
             ASSERT(currentObject != m_paintInvalidationContainer);
             m_svgTransform *= currentObject.localToSVGParentTransform();
             return;
@@ skipping 17 matching lines @@
         return;
 
     if (currentObject.isLayoutView()) {
         ASSERT(&parentState.m_currentObject == toLayoutView(currentObject).frame()->ownerLayoutObject());
         m_paintOffset += toLayoutBox(parentState.m_currentObject).contentBoxOffset();
         // a LayoutView paints with a defined size but a pixel-rounded offset.
         m_paintOffset = LayoutSize(roundedIntSize(m_paintOffset));
         return;
     }
 
+    if (position == FixedPosition) {
+        if (m_paintInvalidationContainer != currentObject.view() && m_paintInvalidationContainer->view() == currentObject.view()) {
+            // TODO(crbug.com/598762): localToAncestorPoint() is incorrect for fixed-position when paintInvalidationContainer
+            // is under the containing LayoutView.
+            m_cachedOffsetsEnabled = false;
+            return;
+        }
+        FloatPoint fixedOffset = currentObject.localToAncestorPoint(FloatPoint(), m_paintInvalidationContainer, TraverseDocumentBoundaries);
+        m_paintOffset = LayoutSize(fixedOffset.x(), fixedOffset.y());
+        // Ancestor clippings are ignored for simplicity.
+        m_clipped = false;
+        return;
+    }
+
+    if (position == AbsolutePosition) {
+        m_cachedOffsetsEnabled = m_cachedOffsetsForAbsolutePositionEnabled;
+        if (!m_cachedOffsetsEnabled)
+            return;
+
+        m_paintOffset = m_paintOffsetForAbsolutePosition;
+        m_clipped = m_clippedForAbsolutePosition;
+        m_clipRect = m_clipRectForAbsolutePosition;
+
+        const LayoutObject& container = parentState.m_containerForAbsolutePosition;
+        if (container.isInFlowPositioned() && container.isLayoutInline())

[chrishtr, 2016/03/31 22:32:11]

What is this code for? Why a special case?

[Xianzhu, 2016/04/01 16:07:56]

This is for
<span style="position: relative">
  <div style="position: absolute"></div>
</span>

The code had been here before my fast-path-to-PaintInvalidationState change, and
I removed it because I mistakenly thought it were incorrect (see
crbug.com/598094 and the blink-dev thread). Removing it didn't break things
because LayoutBlock forced slow-path for the case.

+            m_paintOffset += toLayoutInline(container).offsetForInFlowPositionedInline(toLayoutBox(m_currentObject));
+    }
+
     if (currentObject.isBox())
         m_paintOffset += toLayoutBox(currentObject).locationOffset();
 
     if (currentObject.isInFlowPositioned() && currentObject.hasLayer())
         m_paintOffset += toLayoutBoxModelObject(currentObject).layer()->offsetForInFlowPosition();
 }
 
 void PaintInvalidationState::updateForChildren()
 {
 #if ENABLE(ASSERT)
     ASSERT(!m_didUpdateForChildren);
     m_didUpdateForChildren = true;
 #endif
 
+    updateForNormalChildren();
+
+    if (m_currentObject == m_containerForAbsolutePosition) {
+        if (m_paintInvalidationContainer == m_paintInvalidationContainerForStackedContents) {
+            m_cachedOffsetsForAbsolutePositionEnabled = m_cachedOffsetsEnabled;
+            if (m_cachedOffsetsEnabled) {
+                m_paintOffsetForAbsolutePosition = m_paintOffset;
+                m_clippedForAbsolutePosition = m_clipped;
+                m_clipRectForAbsolutePosition = m_clipRect;
+            }
+        } else {
+            // Cached offsets for absolute-position are from m_paintInvalidationContainer,
+            // which can't be used if the absolute-position descendants will use a different
+            // paintInvalidationContainer.
+            m_cachedOffsetsForAbsolutePositionEnabled = false;
+        }
+    }
+}
+
+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) {
                 m_paintOffset -= toLayoutView(m_currentObject).frameView()->scrollOffset();
@@ skipping 32 matching lines @@
     if (object.isLayoutView())
         return toLayoutView(object).localToAncestorPoint(point, &ancestor, TraverseDocumentBoundaries | InputIsInFrameCoordinates);
     return object.localToAncestorPoint(point, &ancestor, TraverseDocumentBoundaries);
 }
 
 LayoutPoint PaintInvalidationState::computePositionFromPaintInvalidationBacking() const
 {
     ASSERT(!m_didUpdateForChildren);
 
     FloatPoint point;
-    if (m_paintInvalidationContainer != m_currentObject) {
+    if (m_paintInvalidationContainer != &m_currentObject) {
         if (m_cachedOffsetsEnabled) {
             if (m_currentObject.isSVG() && !m_currentObject.isSVGRoot())
                 point = m_svgTransform.mapPoint(point);
             point += FloatPoint(m_paintOffset);
 #if ASSERT_SAME_RESULT_SLOW_AND_FAST_PATH
             // TODO(wangxianzhu): We can't enable this ASSERT for now because of crbug.com/597745.
             // ASSERT(point == slowLocalOriginToAncestorPoint(m_currentObject, m_paintInvalidationContainer, FloatPoint());
 #endif
         } else {
-            point = slowLocalToAncestorPoint(m_currentObject, m_paintInvalidationContainer, FloatPoint());
+            point = slowLocalToAncestorPoint(m_currentObject, *m_paintInvalidationContainer, FloatPoint());
         }
     }
 
-    if (m_paintInvalidationContainer.layer()->groupedMapping())
-        PaintLayer::mapPointInPaintInvalidationContainerToBacking(m_paintInvalidationContainer, point);
+    if (m_paintInvalidationContainer->layer()->groupedMapping())
+        PaintLayer::mapPointInPaintInvalidationContainerToBacking(*m_paintInvalidationContainer, point);
 
     return LayoutPoint(point);
 }
 
 LayoutRect PaintInvalidationState::computePaintInvalidationRectInBacking() const
 {
     ASSERT(!m_didUpdateForChildren);
 
     if (m_currentObject.isSVG() && !m_currentObject.isSVGRoot())
         return computePaintInvalidationRectInBackingForSVG();
 
     LayoutRect rect = m_currentObject.localOverflowRectForPaintInvalidation();
     mapLocalRectToPaintInvalidationBacking(rect);
     return rect;
 }
 
 LayoutRect PaintInvalidationState::computePaintInvalidationRectInBackingForSVG() const
 {
     LayoutRect rect;
     if (m_cachedOffsetsEnabled) {
         FloatRect svgRect = SVGLayoutSupport::localOverflowRectForPaintInvalidation(m_currentObject);
         rect = SVGLayoutSupport::transformPaintInvalidationRect(m_currentObject, m_svgTransform, svgRect);
         rect.move(m_paintOffset);
         if (m_clipped)
             rect.intersect(m_clipRect);
 #if ASSERT_SAME_RESULT_SLOW_AND_FAST_PATH
-        LayoutRect slowPathRect = SVGLayoutSupport::clippedOverflowRectForPaintInvalidation(m_currentObject, m_paintInvalidationContainer);
+        LayoutRect slowPathRect = SVGLayoutSupport::clippedOverflowRectForPaintInvalidation(m_currentObject, *m_paintInvalidationContainer);
         // TODO(crbug.com/597902): Slow path misses clipping of paintInvalidationContainer.
         if (m_clipped)
             slowPathRect.intersect(m_clipRect);
         // TODO(crbug.com/597903): Fast path and slow path should generate equal empty rects.
         ASSERT((rect.isEmpty() && slowPathRect.isEmpty()) || rect == slowPathRect);
 #endif
     } else {
         // TODO(wangxianzhu): Sometimes m_cachedOffsetsEnabled==false doesn't mean we can't use cached
         // m_svgTransform. We can use hybrid fast-path (for SVG) and slow-path (for things above the SVGRoot).
-        rect = SVGLayoutSupport::clippedOverflowRectForPaintInvalidation(m_currentObject, m_paintInvalidationContainer);
+        rect = SVGLayoutSupport::clippedOverflowRectForPaintInvalidation(m_currentObject, *m_paintInvalidationContainer);
     }
 
-    if (m_paintInvalidationContainer.layer()->groupedMapping())
-        PaintLayer::mapRectInPaintInvalidationContainerToBacking(m_paintInvalidationContainer, rect);
+    if (m_paintInvalidationContainer->layer()->groupedMapping())
+        PaintLayer::mapRectInPaintInvalidationContainerToBacking(*m_paintInvalidationContainer, rect);
     return rect;
 }
 
 static void slowMapToVisualRectInAncestorSpace(const LayoutObject& object, const LayoutBoxModelObject& ancestor, LayoutRect& rect)
 {
     // TODO(crbug.com/597965): LayoutBox::mapToVisualRectInAncestorSpace() incorrectly flips a rect
     // in its own space for writing mode. Here flip to workaround the flip.
     if (object.isBox() && (toLayoutBox(object).isWritingModeRoot() || (ancestor == object && object.styleRef().isFlippedBlocksWritingMode())))
         toLayoutBox(object).flipForWritingMode(rect);
 
     if (object.isLayoutView()) {
         toLayoutView(object).mapToVisualRectInAncestorSpace(&ancestor, rect, InputIsInFrameCoordinates, DefaultVisualRectFlags);
     } else if (object.isSVGRoot()) {
         // TODO(crbug.com/597813): This is to avoid the extra clip applied in LayoutSVGRoot::mapVisibleRectInAncestorSpace().
         toLayoutSVGRoot(object).LayoutReplaced::mapToVisualRectInAncestorSpace(&ancestor, rect);
     } else {
         object.mapToVisualRectInAncestorSpace(&ancestor, rect);
     }
 }
 
 void PaintInvalidationState::mapLocalRectToPaintInvalidationBacking(LayoutRect& rect) const
 {
     ASSERT(!m_didUpdateForChildren);
 
     if (m_cachedOffsetsEnabled) {
 #if ASSERT_SAME_RESULT_SLOW_AND_FAST_PATH
         LayoutRect slowPathRect(rect);
-        slowMapToVisualRectInAncestorSpace(m_currentObject, m_paintInvalidationContainer, slowPathRect);
+        slowMapToVisualRectInAncestorSpace(m_currentObject, *m_paintInvalidationContainer, slowPathRect);
 #endif
         rect.move(m_paintOffset);
         if (m_clipped)
             rect.intersect(m_clipRect);
 #if ASSERT_SAME_RESULT_SLOW_AND_FAST_PATH
         // Make sure that the fast path and the slow path generate the same rect.
         // TODO(crbug.com/597902): Slow path misses clipping of paintInvalidationContainer.
         if (m_clipped)
             slowPathRect.intersect(m_clipRect);
         // TODO(wangxianzhu): The isLayoutView() condition is for cases that a sub-frame creates a
         // root PaintInvalidationState which doesn't inherit clip from ancestor frames.
         // Remove the condition when we eliminate the latter case of PaintInvalidationState(const LayoutView&, ...).
+        // We ignore ancestor clipping for FixedPosition in fast path.
         // TODO(crbug.com/597903): Fast path and slow path should generate equal empty rects.
-        ASSERT(m_currentObject.isLayoutView() || (rect.isEmpty() && slowPathRect.isEmpty()) || rect == slowPathRect);
+        ASSERT(m_currentObject.isLayoutView() || m_currentObject.styleRef().position() == FixedPosition || (rect.isEmpty() && slowPathRect.isEmpty()) || rect == slowPathRect);
 #endif
     } else {
-        slowMapToVisualRectInAncestorSpace(m_currentObject, m_paintInvalidationContainer, rect);
+        slowMapToVisualRectInAncestorSpace(m_currentObject, *m_paintInvalidationContainer, rect);
     }
 
-    if (m_paintInvalidationContainer.layer()->groupedMapping())
-        PaintLayer::mapRectInPaintInvalidationContainerToBacking(m_paintInvalidationContainer, rect);
+    if (m_paintInvalidationContainer->layer()->groupedMapping())
+        PaintLayer::mapRectInPaintInvalidationContainerToBacking(*m_paintInvalidationContainer, 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;
         m_clipped = true;
     }
 }
 
 PaintLayer& PaintInvalidationState::enclosingSelfPaintingLayer(const LayoutObject& layoutObject) const
 {
     if (layoutObject.hasLayer() && toLayoutBoxModelObject(layoutObject).hasSelfPaintingLayer())
         return *toLayoutBoxModelObject(layoutObject).layer();
 
     return m_enclosingSelfPaintingLayer;
 }
 
 } // namespace blink