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"
@@ skipping 13 matching lines @@
 #if ASSERT_SAME_RESULT_SLOW_AND_FAST_PATH
 // Make sure that the fast path and the slow path generate the same rect.
 void assertRectsEqual(const LayoutObject& object, const LayoutBoxModelObject& ancestor, const LayoutRect& rect, const LayoutRect& slowPathRect)
 {
     // TODO(wangxianzhu): This 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&, ...).
     if (object.isLayoutView())
         return;
 
+    // We ignore ancestor clipping for FixedPosition in fast path.
+    if (object.styleRef().position() == FixedPosition)

[chrishtr, 2016/04/01 16:38:13]

Is there a bug for this?

[Xianzhu, 2016/04/01 17:07:21]

I would not treat this as a bug, but a trade-off between performance and paint
invalidation accuracy.

When we meet a fixed-position object, we use slow-path to get its paintOffset,
then enable fast-path of its descendants. In this way, we can't get accurate
clip rect from ancestor of the fixed-position object, so just assume no clip.

Clip on fixed-position object is rare, in the following cases:
- the fixed-position object's container is a LayoutView which is not a
paintInvalidationContainer and clipped by something in the owner document;
- the fixed-position object's container is an object with transform and clip.

It's possible that we use a similar technique for absolute-position and their
descendants: even if the absolute-position object itself needs slow-path offset
calculation, we can use fast-path for its descendants. Would like to explore
this way in later CLs.

[chrishtr, 2016/04/01 17:10:36]

Ok. Please document this in the code.

+        return;
+
     // TODO(crbug.com/597903): Fast path and slow path should generate equal empty rects.
     if (rect.isEmpty() && slowPathRect.isEmpty())
         return;
 
     if (rect == slowPathRect)
         return;
 
     // Tolerate the difference between the two paths when crossing frame boundaries.
     if (object.view() != ancestor.view()) {
         LayoutRect inflatedRect = rect;
         inflatedRect.inflate(1);
         if (inflatedRect.contains(slowPathRect))
             return;
         LayoutRect inflatedSlowPathRect = slowPathRect;
         inflatedSlowPathRect.inflate(1);
         if (inflatedSlowPathRect.contains(rect))
             return;
     }
 
 #ifndef NDEBUG
     WTFLogAlways("Fast-path paint invalidation rect differs from slow-path: %s vs %s", rect.toString().ascii().data(), slowPathRect.toString().ascii().data());
     showLayoutTree(&object);
 #endif
     ASSERT_NOT_REACHED();
 }
 #endif
 
-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.hasFilterInducingProperty()
         && !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);
+            // Adjust cached offsets for absolute-position to be relative to this new paintInvalidationContainer.
+            if (m_cachedOffsetsForAbsolutePositionEnabled && m_cachedOffsetsEnabled) {
+                m_paintOffsetForAbsolutePosition -= m_paintOffset;
+                if (m_clippedForAbsolutePosition)
+                    m_clipRectForAbsolutePosition.move(-m_paintOffset);
+            }
+        }
+    } 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;
+    } 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

[chrishtr, 2016/04/01 16:38:13]

Why can't we use the same approach here as line 147?

[Xianzhu, 2016/04/01 17:07:21]

This is because we don't track the offset from
m_paintInvalidationContainerForStackedContents to m_paintInvalidationContainer.
It's different from the case at line 147 in which the new
m_paintInvalidationContainerForStackedContents is the current object and we know
the offset from the original paintInvalidationContainer to it.

However, there are possible optimization opportunities:
- Like what we do for fixed-position, calculate the paint offset in slow-path
and enable fast-path for descendants;
or
- Track offset between the two paintInvalidationContainers.

Would like to explore the above opportunities in later CLs.

+        // 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;
+
+        // Handle absolute-position block under relative-position inline.
+        const LayoutObject& container = parentState.m_containerForAbsolutePosition;
+        if (container.isInFlowPositioned() && container.isLayoutInline())
+            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;

[Xianzhu, 2016/04/01 17:07:21]

There are also optimization opportunities here like line 162.

+        }
+    }
+}
+
+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
         // TODO(crbug.com/597902): Slow path misses clipping of paintInvalidationContainer.
-        LayoutRect slowPathRect = SVGLayoutSupport::clippedOverflowRectForPaintInvalidation(m_currentObject, m_paintInvalidationContainer);
+        LayoutRect slowPathRect = SVGLayoutSupport::clippedOverflowRectForPaintInvalidation(m_currentObject, *m_paintInvalidationContainer);
         if (m_clipped)
             slowPathRect.intersect(m_clipRect);
         assertRectsEqual(m_currentObject, m_paintInvalidationContainer, 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
         // TODO(crbug.com/597902): Slow path misses clipping of paintInvalidationContainer.
         if (m_clipped)
             slowPathRect.intersect(m_clipRect);
-        assertRectsEqual(m_currentObject, m_paintInvalidationContainer, rect, slowPathRect);
+        assertRectsEqual(m_currentObject, *m_paintInvalidationContainer, 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