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/layout/LayoutInline.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 LayoutSize computeViewPaintOffset(const LayoutView& layoutView, const LayoutBoxModelObject& paintInvalidationContainer)

[chrishtr, 2016/03/24 00:53:52]

computePaintOffsetFromViewToContainer.

Rename paintInvalidationContainer to container.

[Xianzhu, 2016/03/25 16:35:54]

Inlined this into the only call site after the other call site is changed to use
fast path.

+{
+    LayoutView::setViewClippingAndScrollOffsetDisabled(true);
+    FloatPoint point = layoutView.localToAncestorPoint(FloatPoint(), &paintInvalidationContainer, TraverseDocumentBoundaries);
+    LayoutView::setViewClippingAndScrollOffsetDisabled(false);
+    return LayoutSize(point.x(), point.y());
+}
+
+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();
+}
+
+static bool supportsCachedOffsetsForChildren(const LayoutObject& object)

[chrishtr, 2016/03/24 16:58:53]

What's the purpose of distinguishing this from supportsCachedOffsets? It appears
the old code didn't do
that.

[Xianzhu, 2016/03/25 16:35:54]

The old code didn't separate paintOffset adjustment for the current object (now
in the constructor) and for children (now in updateForChildren()), so it didn't
need to distinguish supportsCachedOffsetsForChildren().
FlippedBlocksWritingMode() doesn't affect application of paintOffset for the
current object.

+{
+    ASSERT(supportsCachedOffsets(object));
+    return !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;
+    m_paintOffset = computeViewPaintOffset(layoutView, m_paintInvalidationContainer);
 }
 
 // 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.

[chrishtr, 2016/03/24 16:58:53]

Are the cases the "horribly-slow" exceptions in LayoutBlock?

[Xianzhu, 2016/03/25 16:35:54]

Yes, and another case is LayoutView. FrameView/LayoutPart creates a
PaintInvalidationState for layoutView, and LayoutBlock::invalidateTreeIfNeeded()
will create another one on the same layoutView.

Included the cases in comment.

+        // 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())
-        m_cachedOffsetsEnabled = false;
-    if (establishesPaintInvalidationContainer) {
+    if (!currentObject.isBoxModelObject() && !currentObject.isSVG())
+        return;
+
+    if (m_cachedOffsetsEnabled) {

[chrishtr, 2016/03/24 16:58:53]

Can this just be (combining also logic from line 135):

m_cachedOffsetsEnabled = m_cachedOffsetsEnabled &&
supportsCachedOffsets(currentObject);

if (currentObject.isSVG()) {
  if (currentObject.isSVGRoot())
    m_svgTransform =
AffineTransform(toLayoutSVGRoot(currentObject).localToBorderBoxTransform());
  else
    m_svgTransform = AffineTransform(m_svgTransform *
currentObject.localToSVGParentTransform());
  return;
}

It appears harmless to set m_svgTransform if m_cachedOffsetsEnabled is false,
but that could also be added to the above conditional.

[Xianzhu, 2016/03/25 16:35:54]

Rearranged the code to set m_svgTransform regardless of m_cachedOffsetsEnabled.
This exposes a chance that we could use hybrid fast-path (for SVG) and slow-path
(for things above the SVGRoot) in some cases. Added a TODO in
computePaintInvalidationRectInBackingForSVG().

+        if (!supportsCachedOffsets(currentObject))
+            m_cachedOffsetsEnabled = false;
+        else if (currentObject.isSVGRoot())
+            m_svgTransform = AffineTransform(toLayoutSVGRoot(currentObject).localToBorderBoxTransform());
+    }
+
+    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;
+        return;
     }
 
-    if (m_cachedOffsetsEnabled && m_currentObject.isSVGRoot()) {
+    if (!m_cachedOffsetsEnabled)
+        return;
+
+    if (currentObject.isSVG() && !currentObject.isSVGRoot()) {
+        // TODO(wangxianzhu): SVG could probably benefit from a stack-based optimization like html does. crbug.com/391054.
+        m_svgTransform = AffineTransform(m_svgTransform * currentObject.localToSVGParentTransform());

[chrishtr, 2016/03/24 01:05:42]

How about a collection of unittests for all of the special cases in this file,
that compares a version
that uses PaintInvalidationState to the one that uses the slow-path fallback?

Or debug code that ASSERTs the slow path equals the fast path for all layout
tests at least, if the above
is too onerous?

[chrishtr, 2016/03/24 16:58:53]

Another option: make this method a helper method, and unittest it directly for
cases of views, table cells, fixed-position, etc.

[Xianzhu, 2016/03/25 16:35:54]

Added ASSERTs in debug mode.

+        return;
+    }
+
+    if (currentObject.isLayoutView()) {
+        m_paintOffset = computeViewPaintOffset(toLayoutView(currentObject), m_paintInvalidationContainer);

[chrishtr, 2016/03/24 00:53:52]

This is an O(tree depth) computation. Is there no way to make it O(1). e.g. add
the offsets that
are implemented in LayoutView's geometry code to the owning element offsets?

[Xianzhu, 2016/03/25 16:35:54]

Done.

+        return;
+    }
+
+    if (currentObject.styleRef().position() == FixedPosition) {
+        // TODO(wangxianzhu): Replace localToAncestorPoint with fast path.
+        FloatPoint fixedOffset = currentObject.localToAncestorPoint(FloatPoint(), &m_paintInvalidationContainer, TraverseDocumentBoundaries);
+        m_paintOffset = LayoutSize(fixedOffset.x(), fixedOffset.y());
+        m_clipped = false;
+        return;
+    }
+
+    if (currentObject.isBox()) {
+        m_paintOffset += toLayoutBox(currentObject).locationOffset();

[chrishtr, 2016/03/24 16:58:53]

This code looks different than the old code. The old code looks like it was
applying locationOffset
for everything except table rows.

[Xianzhu, 2016/03/25 16:35:54]

In this CL, paintOffset adjustment for the current object is moved from
updatePaintOffsetAndClipForChildren() into the constructor, so that in fast path
mapping, we don't need to apply the offsets of the current object again.

Previously paintOffset adjustment in PaintInvalidationState was for children
only, so LayoutTableRow should not add its locationOffset for child
LayoutTableCells. Now paintOffset adjustment here is for the current object, if
the current object is a LayoutTableRow, it needs to add locationOffset normally
for its own mapping; In the PaintInvalidationState for LayoutTableCell, the
row's offset should be excluded for the cell.

However, I moved the exclusion into updateForChildren() so that we can just
exclude once for a row instead of exclude for each cell.

+        if (currentObject.isTableCell()) {
+            // A table cell's locationOffset() includes its row's locationOffset().
+            m_paintOffset -= toLayoutBox(currentObject.parent())->locationOffset();
+        }
+    }
+
+    if (currentObject.styleRef().position() == AbsolutePosition) {
+        if (LayoutObject* container = currentObject.container()) {
+            if (container->isInFlowPositioned() && container->isLayoutInline())
+                m_paintOffset += toLayoutInline(container)->offsetForInFlowPositionedInline(toLayoutBox(currentObject));
+        }
+        return;
+    }
+
+    if (currentObject.isInFlowPositioned() && currentObject.hasLayer())
+        m_paintOffset += toLayoutBoxModelObject(currentObject).layer()->offsetForInFlowPosition();
+}
+
+void PaintInvalidationState::updateForChildren()
+{
+#if ENABLE(ASSERT)
+    ASSERT(!m_didUpdateForChildren);
+    m_didUpdateForChildren = true;
+#endif
+
+    if (!m_cachedOffsetsEnabled)
+        return;
+
+    if (!supportsCachedOffsetsForChildren(m_currentObject)) {
+        m_cachedOffsetsEnabled = false;
+        return;
+    }
+
+    if (!m_currentObject.isBoxModelObject() && !m_currentObject.isSVG())
+        return;

[chrishtr, 2016/03/24 16:58:53]

The old code asserted that isSVG is true...why the difference?

[Xianzhu, 2016/03/25 16:35:54]

Previously we didn't create new PaintInvalidationState for
non-LayoutBoxModelObject and non-SVG objects. (in old
LayoutObject::invalidateTreeIfNeeded), so there were only two cases. In that
way, we may reuse a PaintInvalidationState created for the parent on a child.

Now we need m_currentObject to be always the real current object, otherwise
we'll need to pass the real object into the new mapping methods.

The early return here is because PaintInvalidationState for such an object
doesn't need the following code.

+
+    if (m_currentObject.isLayoutView()) {
+        if (m_currentObject != m_paintInvalidationContainer) {
+            // TODO(wangxianzhu): Replace localToAncestorPoint with fast path.

[chrishtr, 2016/03/24 00:53:52]

Looks like this is referring to the fast path I suggested above..

[Xianzhu, 2016/03/25 16:35:54]

Done.

+            FloatPoint viewOffset = m_currentObject.localToAncestorPoint(FloatPoint(), &m_paintInvalidationContainer, TraverseDocumentBoundaries);
+            m_paintOffset = LayoutSize(viewOffset.x(), viewOffset.y());
+            m_clipRect = toLayoutView(m_currentObject).viewRect();
+            m_clipRect.move(m_paintOffset);
+            m_clipped = true;
+            return;
+        }
+    } else if (m_currentObject.isSVGRoot()) {
         const LayoutSVGRoot& svgRoot = toLayoutSVGRoot(m_currentObject);
-        m_svgTransform = AffineTransform(svgRoot.localToBorderBoxTransform());
         if (svgRoot.shouldApplyViewportClip())
             addClipRectRelativeToPaintOffset(LayoutSize(svgRoot.pixelSnappedSize()));
     }
 
-    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()));
+
+    m_paintOffset -= box.scrolledContentOffset();
 
     // 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
+LayoutPoint PaintInvalidationState::computePositionFromPaintInvalidationBacking() const
 {
-    ASSERT(canMapToAncestor(ancestor));
-
-    if (ancestor == &object) {
-        if (object.isBox() && object.styleRef().isFlippedBlocksWritingMode())
-            toLayoutBox(object).flipForWritingMode(rect);
-        return;
+    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);
+        } else {
+            // Fallback to slow path.
+            point = m_currentObject.localToAncestorPoint(FloatPoint(), &m_paintInvalidationContainer);
+        }
     }
 
-    if (object.hasLayer()) {
-        if (const TransformationMatrix* transform = toLayoutBoxModelObject(object).layer()->transform())
-            rect = LayoutRect(transform->mapRect(pixelSnappedIntRect(rect)));
+    if (m_paintInvalidationContainer.layer()->groupedMapping())
+        PaintLayer::mapPointInPaintInvalidationContainerToBacking(m_paintInvalidationContainer, point);
 
-        if (object.isInFlowPositioned())
-            rect.move(toLayoutBoxModelObject(object).layer()->offsetForInFlowPosition());
+    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);
+    } else {
+        rect = SVGLayoutSupport::clippedOverflowRectForPaintInvalidation(m_currentObject, m_paintInvalidationContainer);
     }
 
-    if (object.isBox())
-        rect.moveBy(toLayoutBox(object).location());
+    if (m_paintInvalidationContainer.layer()->groupedMapping())
+        PaintLayer::mapRectInPaintInvalidationContainerToBacking(m_paintInvalidationContainer, rect);
+    return rect;
+}
 
-    rect.move(m_paintOffset);
+void PaintInvalidationState::mapLocalRectToPaintInvalidationBacking(LayoutRect& rect) const
+{
+    if (m_cachedOffsetsEnabled) {
+        rect.move(m_paintOffset);
+        if (m_clipped)
+            rect.intersect(m_clipRect);
+    } else {
+        // Fallback to slow path.
+        m_currentObject.mapToVisibleRectInAncestorSpace(&m_paintInvalidationContainer, rect);
+    }
 
-    if (m_clipped)
-        rect.intersect(m_clipRect);
+    if (m_paintInvalidationContainer.layer()->groupedMapping())
+        PaintLayer::mapRectInPaintInvalidationContainerToBacking(m_paintInvalidationContainer, rect);
 }
 
 void PaintInvalidationState::addClipRectRelativeToPaintOffset(const LayoutSize& clipSize)
 {
     LayoutRect clipRect(toPoint(m_paintOffset), clipSize);
     if (m_clipped) {
         m_clipRect.intersect(clipRect);
     } else {
         m_clipRect = clipRect;
         m_clipped = true;
     }
 }
 
-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()));
-
-    m_paintOffset -= box.scrolledContentOffset();
-}
-
 PaintLayer& PaintInvalidationState::enclosingSelfPaintingLayer(const LayoutObject& layoutObject) const
 {
     if (layoutObject.hasLayer() && toLayoutBoxModelObject(layoutObject).hasSelfPaintingLayer())
         return *toLayoutBoxModelObject(layoutObject).layer();
 
     return m_enclosingSelfPaintingLayer;
 }
 
 } // namespace blink