Move all fast-path paint invalidation mapping into PaintInvalidationState

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"
 
 namespace blink {
 
-PaintInvalidationState::PaintInvalidationState(const LayoutView& layoutView, Vector<LayoutObject*>& pendingDelayedPaintInvalidations, const PaintInvalidationState* ownerPaintInvalidationState)
+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.styleRef().position() != FixedPosition
+        && !object.styleRef().isFlippedBlocksWritingMode();
+}
+
+PaintInvalidationState::PaintInvalidationState(const LayoutView& layoutView, Vector<LayoutObject*>& pendingDelayedPaintInvalidations)
     : m_currentObject(layoutView)
     , m_clipped(false)
     , m_cachedOffsetsEnabled(true)
     , m_forcedSubtreeInvalidationWithinContainer(false)
     , m_forcedSubtreeInvalidationRectUpdateWithinContainer(false)
-    , m_viewClippingAndScrollOffsetDisabled(false)
     , m_paintInvalidationContainer(layoutView.containerForPaintInvalidation())
     , m_pendingDelayedPaintInvalidations(pendingDelayedPaintInvalidations)
     , m_enclosingSelfPaintingLayer(*layoutView.layer())
 #if ENABLE(ASSERT)
-    , m_didUpdatePaintOffsetAndClipForChildren(true)
+    , m_didUpdateForChildren(false)
 #endif
 {
-    ASSERT(!ownerPaintInvalidationState || ownerPaintInvalidationState->m_didUpdatePaintOffsetAndClipForChildren);
+    if (!supportsCachedOffsets(layoutView)) {
+        m_cachedOffsetsEnabled = false;
+        return;
+    }
 
-    bool establishesPaintInvalidationContainer = layoutView == m_paintInvalidationContainer;
-    if (!establishesPaintInvalidationContainer) {
-        if ((ownerPaintInvalidationState && !ownerPaintInvalidationState->m_cachedOffsetsEnabled)
-            || !layoutView.supportsPaintInvalidationStateCachedOffsets()) {
-            m_cachedOffsetsEnabled = false;
-            return;
-        }
-        if (ownerPaintInvalidationState && ownerPaintInvalidationState->m_forcedSubtreeInvalidationWithinContainer)
-            m_forcedSubtreeInvalidationWithinContainer = true;
-        FloatPoint point = layoutView.localToAncestorPoint(FloatPoint(), &m_paintInvalidationContainer, TraverseDocumentBoundaries);
-        m_paintOffset = LayoutSize(point.x(), point.y());
-    }
-    m_clipRect = layoutView.viewRect();
-    m_clipRect.move(m_paintOffset);
-    m_clipped = true;
+    FloatPoint point = layoutView.localToAncestorPoint(FloatPoint(), &m_paintInvalidationContainer, TraverseDocumentBoundaries | DontApplyFrameScrollOffsetAndClip);
+    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_viewClippingAndScrollOffsetDisabled(false)
     , 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_didUpdatePaintOffsetAndClipForChildren(true)
+    , m_didUpdateForChildren(true)
 #endif
 {
-    ASSERT(parentState.m_didUpdatePaintOffsetAndClipForChildren);
+    ASSERT(parentState.m_didUpdateForChildren);
     ASSERT(!m_cachedOffsetsEnabled);
 }
 
 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_viewClippingAndScrollOffsetDisabled(false)
     , m_clipRect(parentState.m_clipRect)
     , m_paintOffset(parentState.m_paintOffset)
     , m_paintInvalidationContainer(currentObject.isPaintInvalidationContainer() ? toLayoutBoxModelObject(currentObject) : parentState.m_paintInvalidationContainer)
     , m_svgTransform(parentState.m_svgTransform)
     , m_pendingDelayedPaintInvalidations(parentState.pendingDelayedPaintInvalidationTargets())
     , m_enclosingSelfPaintingLayer(parentState.enclosingSelfPaintingLayer(currentObject))
 #if ENABLE(ASSERT)
-    , m_didUpdatePaintOffsetAndClipForChildren(false)
+    , m_didUpdateForChildren(false)
 #endif
 {
-    ASSERT(parentState.m_didUpdatePaintOffsetAndClipForChildren);
-}
-
-void PaintInvalidationState::updatePaintOffsetAndClipForChildren()
-{
+    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)
-    ASSERT(!m_didUpdatePaintOffsetAndClipForChildren);
-    m_didUpdatePaintOffsetAndClipForChildren = true;
+        m_didUpdateForChildren = parentState.m_didUpdateForChildren;
 #endif
-
-    bool establishesPaintInvalidationContainer = m_currentObject == m_paintInvalidationContainer;
-
-    if (!m_currentObject.isBoxModelObject()) {
-        // TODO(wangxianzhu): SVG could probably benefit from a stack-based optimization like html does. crbug.com/391054.
-        ASSERT(m_currentObject.isSVG());
-        ASSERT(!establishesPaintInvalidationContainer);
-        if (m_cachedOffsetsEnabled)
-            m_svgTransform = AffineTransform(m_svgTransform * m_currentObject.localToSVGParentTransform());
         return;
     }
 
-    bool fixed = m_currentObject.style()->position() == FixedPosition;
+    ASSERT(parentState.m_didUpdateForChildren);
 
-    if (!m_currentObject.supportsPaintInvalidationStateCachedOffsets())
+    if (!currentObject.isBoxModelObject() && !currentObject.isSVG())
+        return;
+
+    if (m_cachedOffsetsEnabled && !supportsCachedOffsets(currentObject))
         m_cachedOffsetsEnabled = false;
-    if (establishesPaintInvalidationContainer) {
+
+    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;
+        }
+    }
+
+    if (currentObject == m_paintInvalidationContainer) {
         // When we hit a new paint invalidation container, we don't need to
         // continue forcing a check for paint invalidation, since we're
         // descending into a different invalidation container. (For instance if
         // our parents were moved, the entire container will just move.)
         m_forcedSubtreeInvalidationWithinContainer = false;
         m_forcedSubtreeInvalidationRectUpdateWithinContainer = false;
 
-        m_clipped = false; // Will be updated in applyClipIfNeeded().
+        m_clipped = false; // Will be updated in updateForChildren().
         m_paintOffset = LayoutSize();
-    } else {
-        if (m_cachedOffsetsEnabled) {
-            if (fixed) {
-                FloatPoint fixedOffset = m_currentObject.localToAncestorPoint(FloatPoint(), &m_paintInvalidationContainer, TraverseDocumentBoundaries);
-                m_paintOffset = LayoutSize(fixedOffset.x(), fixedOffset.y());
-            } else if (m_currentObject.isBox() && !m_currentObject.isTableRow()) {
-                // We don't add locationOffset of table row because the child cells' location offsets include the row's location offset.
-                m_paintOffset += toLayoutBox(m_currentObject).locationOffset();
-            }
-
-            if (m_currentObject.isOutOfFlowPositioned() && !fixed) {
-                if (LayoutObject* container = m_currentObject.container()) {
-                    if (container->isInFlowPositioned() && container->isLayoutInline())
-                        m_paintOffset += toLayoutInline(container)->offsetForInFlowPositionedInline(toLayoutBox(m_currentObject));
-                }
-            }
-
-            if (m_currentObject.isInFlowPositioned() && m_currentObject.hasLayer())
-                m_paintOffset += toLayoutBoxModelObject(m_currentObject).layer()->offsetForInFlowPosition();
-        }
-
-        m_clipped = !fixed && m_clipped;
-    }
-
-    if (m_cachedOffsetsEnabled && m_currentObject.isSVGRoot()) {
-        const LayoutSVGRoot& svgRoot = toLayoutSVGRoot(m_currentObject);
-        m_svgTransform = AffineTransform(svgRoot.localToBorderBoxTransform());
-        if (svgRoot.shouldApplyViewportClip())
-            addClipRectRelativeToPaintOffset(LayoutSize(svgRoot.pixelSnappedSize()));
-    }
-
-    applyClipIfNeeded();
-
-    // FIXME: <http://bugs.webkit.org/show_bug.cgi?id=13443> Apply control clip if present.
-}
-
-void PaintInvalidationState::mapObjectRectToAncestor(const LayoutObject& object, const LayoutBoxModelObject* ancestor, LayoutRect& rect) const
-{
-    ASSERT(canMapToAncestor(ancestor));
-
-    if (ancestor == &object) {
-        if (object.isBox() && object.styleRef().isFlippedBlocksWritingMode())
-            toLayoutBox(object).flipForWritingMode(rect);
         return;
     }
 
-    if (object.hasLayer()) {
-        if (const TransformationMatrix* transform = toLayoutBoxModelObject(object).layer()->transform())
-            rect = LayoutRect(transform->mapRect(pixelSnappedIntRect(rect)));
+    if (!m_cachedOffsetsEnabled)
+        return;
 
-        if (object.isInFlowPositioned())
-            rect.move(toLayoutBoxModelObject(object).layer()->offsetForInFlowPosition());
+    if (currentObject.isLayoutView()) {
+        ASSERT(&parentState.m_currentObject == toLayoutView(currentObject).frame()->ownerLayoutObject());
+        m_paintOffset += toLayoutBox(parentState.m_currentObject).contentBoxOffset();
+        return;
     }
 
-    if (object.isBox())
-        rect.moveBy(toLayoutBox(object).location());
+    if (currentObject.isBox())
+        m_paintOffset += toLayoutBox(currentObject).locationOffset();
 
-    rect.move(m_paintOffset);
+    if (currentObject.styleRef().position() == AbsolutePosition) {
+        if (LayoutObject* container = currentObject.container()) {
+            if (container->isInFlowPositioned() && container->isLayoutInline())
+                m_paintOffset += toLayoutInline(container)->offsetForInFlowPositionedInline(toLayoutBox(currentObject));
+        }
+        return;
+    }
 
-    if (m_clipped)
-        rect.intersect(m_clipRect);
+    if (currentObject.isInFlowPositioned() && currentObject.hasLayer())
+        m_paintOffset += toLayoutBoxModelObject(currentObject).layer()->offsetForInFlowPosition();
 }
 
-void PaintInvalidationState::addClipRectRelativeToPaintOffset(const LayoutSize& clipSize)
+void PaintInvalidationState::updateForChildren()
 {
-    LayoutRect clipRect(toPoint(m_paintOffset), clipSize);
-    if (m_clipped) {
-        m_clipRect.intersect(clipRect);
-    } else {
-        m_clipRect = clipRect;
-        m_clipped = true;
+#if ENABLE(ASSERT)
+    ASSERT(!m_didUpdateForChildren);
+    m_didUpdateForChildren = true;
+#endif
+
+    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())
+            && m_currentObject != m_paintInvalidationContainer) {
+            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();
     }
-}
 
-void PaintInvalidationState::applyClipIfNeeded()
-{
     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.usesCompositedScrolling())
         ASSERT(!m_clipped); // The box should establish paint invalidation container, so no m_clipped inherited.
     else
-        addClipRectRelativeToPaintOffset(LayoutSize(box.layer()->size()));
+        addClipRectRelativeToPaintOffset(LayoutRect(LayoutPoint(), LayoutSize(box.layer()->size())));
 
     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)
+{
+    if (object.isLayoutView())
+        return toLayoutView(object).localToAncestorPoint(point, &ancestor, TraverseDocumentBoundaries | DontApplyFrameScrollOffsetAndClip);
+    return object.localToAncestorPoint(point, &ancestor, TraverseDocumentBoundaries);
+}
+
+LayoutPoint PaintInvalidationState::computePositionFromPaintInvalidationBacking() const
+{
+    FloatPoint point;
+    if (m_paintInvalidationContainer != m_currentObject) {
+        if (m_cachedOffsetsEnabled) {
+            if (m_currentObject.isSVG() && !m_currentObject.isSVGRoot())
+                point = m_svgTransform.mapPoint(point);
+            point += FloatPoint(m_paintOffset);
+#ifndef NDEBUG
+            // Make sure that the fast path and the slow path generate the same point.
+            // 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());
+        }
+    }
+
+    if (m_paintInvalidationContainer.layer()->groupedMapping())
+        PaintLayer::mapPointInPaintInvalidationContainerToBacking(m_paintInvalidationContainer, point);
+
+    return LayoutPoint(point);
+}
+
+LayoutRect PaintInvalidationState::computePaintInvalidationRectInBacking() const
+{
+    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 !defined(NDEBUG) && ENABLE(ASSERT)
+        // Make sure that the fast path and the slow path generate the same rect.
+        LayoutRect slowPathRect = SVGLayoutSupport::clippedOverflowRectForPaintInvalidation(m_currentObject, m_paintInvalidationContainer);
+        if (m_clipped)
+            slowPathRect.intersect(m_clipRect);
+        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);
+    }
+
+    if (m_paintInvalidationContainer.layer()->groupedMapping())
+        PaintLayer::mapRectInPaintInvalidationContainerToBacking(m_paintInvalidationContainer, rect);
+    return rect;
+}
+
+static void slowMapToVisibleRectInAncestorSpace(const LayoutObject& object, const LayoutBoxModelObject& ancestor, LayoutRect& rect)
+{
+    if (object.isLayoutView()) {
+        toLayoutView(object).mapToVisibleRectInAncestorSpace(&ancestor, rect, DontApplyFrameScrollOffsetAndClip);
+    } else if (object.isSVGRoot()) {
+        // TODO(crbug.com/597813): This is to avoid the extra clip applied in LayoutSVGRoot::mapVisibleRectInAncestorSpace().
+        toLayoutSVGRoot(object).LayoutReplaced::mapToVisibleRectInAncestorSpace(&ancestor, rect);
+    } else {
+        object.mapToVisibleRectInAncestorSpace(&ancestor, rect);
+    }
+}
+
+void PaintInvalidationState::mapLocalRectToPaintInvalidationBacking(LayoutRect& rect) const
+{
+    if (m_cachedOffsetsEnabled) {
+#if !defined(NDEBUG) && ENABLE(ASSERT)
+        LayoutRect slowPathRect(rect);
+        slowMapToVisibleRectInAncestorSpace(m_currentObject, m_paintInvalidationContainer, slowPathRect);
+#endif
+        rect.move(m_paintOffset);
+        if (m_clipped)
+            rect.intersect(m_clipRect);
+#if !defined(NDEBUG) && ENABLE(ASSERT)
+        // Make sure that the fast path and the slow path generate the same rect.
+        // 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&, ...).
+        ASSERT(m_currentObject.isLayoutView() || (rect.isEmpty() && slowPathRect.isEmpty()) || rect == slowPathRect);
+#endif
+    } else {
+        slowMapToVisibleRectInAncestorSpace(m_currentObject, 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