Change PaintLayer::m_layoutObject to a reference.

third_party/WebKit/Source/core/paint/PaintLayerPainter.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/paint/PaintLayerPainter.h"
 
 #include "core/frame/LocalFrame.h"
 #include "core/layout/LayoutView.h"
 #include "core/paint/ClipPathClipper.h"
 #include "core/paint/FilterPainter.h"
@@ skipping 18 matching lines @@
 
 namespace blink {
 
 static inline bool shouldSuppressPaintingLayer(const PaintLayer& layer) {
   // Avoid painting descendants of the root layer when stylesheets haven't
   // loaded. This avoids some FOUC.  It's ok not to draw, because later on, when
   // all the stylesheets do load, Document::styleResolverMayHaveChanged() will
   // invalidate all painted output via a call to
   // LayoutView::invalidatePaintForViewAndCompositedLayers().  We also avoid
   // caching subsequences in this mode; see shouldCreateSubsequence().
-  if (layer.layoutObject()->document().didLayoutWithPendingStylesheets() &&
-      !layer.isRootLayer() && !layer.layoutObject()->isDocumentElement())
+  if (layer.layoutObject().document().didLayoutWithPendingStylesheets() &&
+      !layer.isRootLayer() && !layer.layoutObject().isDocumentElement())
     return true;
 
   return false;
 }
 
 void PaintLayerPainter::paint(GraphicsContext& context,
                               const LayoutRect& damageRect,
                               const GlobalPaintFlags globalPaintFlags,
                               PaintLayerFlags paintFlags) {
   PaintLayerPaintingInfo paintingInfo(&m_paintLayer,
                                       LayoutRect(enclosingIntRect(damageRect)),
                                       globalPaintFlags, LayoutSize());
   if (shouldPaintLayerInSoftwareMode(globalPaintFlags, paintFlags))
     paint(context, paintingInfo, paintFlags);
 }
 
 static ShouldRespectOverflowClipType shouldRespectOverflowClip(
     PaintLayerFlags paintFlags,
-    const LayoutObject* layoutObject) {
+    const LayoutObject& layoutObject) {
   return (paintFlags & PaintLayerPaintingOverflowContents ||
           (paintFlags & PaintLayerPaintingChildClippingMaskPhase &&
-           layoutObject->hasClipPath()))
+           layoutObject.hasClipPath()))
              ? IgnoreOverflowClip
              : RespectOverflowClip;
 }
 
 bool PaintLayerPainter::paintedOutputInvisible(
     const PaintLayerPaintingInfo& paintingInfo) {
-  const LayoutObject& layoutObject = *m_paintLayer.layoutObject();
+  const LayoutObject& layoutObject = m_paintLayer.layoutObject();
   if (layoutObject.hasBackdropFilter())
     return false;
 
   if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
     if (layoutObject.styleRef().opacity())
       return false;
 
     const EffectPaintPropertyNode* effect =
         layoutObject.paintProperties()->effect();
     const TransformPaintPropertyNode* transform =
@@ skipping 36 matching lines @@
 
   // Non self-painting layers without self-painting descendants don't need to be
   // painted as their layoutObject() should properly paint itself.
   if (!m_paintLayer.isSelfPaintingLayer() &&
       !m_paintLayer.hasSelfPaintingLayerDescendant())
     return FullyPainted;
 
   if (shouldSuppressPaintingLayer(m_paintLayer))
     return FullyPainted;
 
-  if (m_paintLayer.layoutObject()->view()->frame() &&
-      m_paintLayer.layoutObject()->view()->frame()->shouldThrottleRendering())
+  if (m_paintLayer.layoutObject().view()->frame() &&
+      m_paintLayer.layoutObject().view()->frame()->shouldThrottleRendering())
     return FullyPainted;
 
   // If this layer is totally invisible then there is nothing to paint.
   if (paintedOutputInvisible(paintingInfo))
     return FullyPainted;
 
   if (m_paintLayer.paintsWithTransparency(paintingInfo.getGlobalPaintFlags()))
     paintFlags |= PaintLayerHaveTransparency;
 
   if (m_paintLayer.paintsWithTransform(paintingInfo.getGlobalPaintFlags()) &&
@@ skipping 39 matching lines @@
   if (paintingInfo.getGlobalPaintFlags() & GlobalPaintFlattenCompositingLayers)
     return false;
   if (paintFlags &
       (PaintLayerPaintingRootBackgroundOnly |
        PaintLayerPaintingOverlayScrollbars | PaintLayerUncachedClipRects))
     return false;
 
   // Create subsequence for only stacking contexts whose painting are atomic.
   // SVG is also painted atomically.
   if (!paintLayer.stackingNode()->isStackingContext() &&
-      !paintLayer.layoutObject()->isSVGRoot())
+      !paintLayer.layoutObject().isSVGRoot())
     return false;
 
   // The layer doesn't have children. Subsequence caching is not worth because
   // normally the actual painting will be cheap.
   // SVG is also painted atomically.
   if (!PaintLayerStackingNodeIterator(*paintLayer.stackingNode(), AllChildren)
            .next() &&
-      !paintLayer.layoutObject()->isSVGRoot())
+      !paintLayer.layoutObject().isSVGRoot())
     return false;
 
   // When in FOUC-avoidance mode, don't cache any subsequences, to avoid having
   // to invalidate all of them when leaving this mode. There is an early-out in
   // BlockPainter::paintContents that may result in nothing getting painted in
   // this mode, in addition to early-out logic in PaintLayerPainter.
-  if (paintLayer.layoutObject()->document().didLayoutWithPendingStylesheets())
+  if (paintLayer.layoutObject().document().didLayoutWithPendingStylesheets())
     return false;
 
   return true;
 }
 
 static bool shouldRepaintSubsequence(
     PaintLayer& paintLayer,
     const PaintLayerPaintingInfo& paintingInfo,
     ShouldRespectOverflowClipType respectOverflowClip,
     const LayoutSize& subpixelAccumulation,
@@ skipping 49 matching lines @@
 }
 
 PaintResult PaintLayerPainter::paintLayerContents(
     GraphicsContext& context,
     const PaintLayerPaintingInfo& paintingInfoArg,
     PaintLayerFlags paintFlags,
     FragmentPolicy fragmentPolicy) {
   Optional<ScopedPaintChunkProperties> scopedPaintChunkProperties;
   if (RuntimeEnabledFeatures::slimmingPaintV2Enabled() &&
       RuntimeEnabledFeatures::rootLayerScrollingEnabled() &&
-      m_paintLayer.layoutObject() &&
-      m_paintLayer.layoutObject()->isLayoutView()) {
+      m_paintLayer.layoutObject().isLayoutView()) {
     const auto* objectPaintProperties =
-        m_paintLayer.layoutObject()->paintProperties();
+        m_paintLayer.layoutObject().paintProperties();
     DCHECK(objectPaintProperties &&
            objectPaintProperties->localBorderBoxProperties());
     PaintChunkProperties properties(
         context.getPaintController().currentPaintChunkProperties());
     properties.propertyTreeState =
         *objectPaintProperties->localBorderBoxProperties();
-    properties.backfaceHidden =
-        m_paintLayer.layoutObject()->hasHiddenBackface();
+    properties.backfaceHidden = m_paintLayer.layoutObject().hasHiddenBackface();
     scopedPaintChunkProperties.emplace(context.getPaintController(),
                                        m_paintLayer, properties);
   }
 
   DCHECK(m_paintLayer.isSelfPaintingLayer() ||
          m_paintLayer.hasSelfPaintingLayerDescendant());
   DCHECK(!(paintFlags & PaintLayerAppliedTransform));
 
   bool isSelfPaintingLayer = m_paintLayer.isSelfPaintingLayer();
   bool isPaintingOverlayScrollbars =
       paintFlags & PaintLayerPaintingOverlayScrollbars;
   bool isPaintingScrollingContent =
       paintFlags & PaintLayerPaintingCompositingScrollingPhase;
   bool isPaintingCompositedForeground =
       paintFlags & PaintLayerPaintingCompositingForegroundPhase;
   bool isPaintingCompositedBackground =
       paintFlags & PaintLayerPaintingCompositingBackgroundPhase;
   bool isPaintingCompositedDecoration =
       paintFlags & PaintLayerPaintingCompositingDecorationPhase;
   bool isPaintingOverflowContents =
       paintFlags & PaintLayerPaintingOverflowContents;
   // Outline always needs to be painted even if we have no visible content.
   // It is painted as part of the decoration phase which paints content that
   // is not scrolled and should be above scrolled content.
   bool shouldPaintSelfOutline =
       isSelfPaintingLayer && !isPaintingOverlayScrollbars &&
       (isPaintingCompositedDecoration || !isPaintingScrollingContent) &&
-      m_paintLayer.layoutObject()->styleRef().hasOutline();
+      m_paintLayer.layoutObject().styleRef().hasOutline();
 
   PaintResult result = FullyPainted;
 
   if (paintFlags & PaintLayerPaintingRootBackgroundOnly &&
-      !m_paintLayer.layoutObject()->isLayoutView())
+      !m_paintLayer.layoutObject().isLayoutView())
     return result;
 
-  if (m_paintLayer.layoutObject()->view()->frame() &&
-      m_paintLayer.layoutObject()->view()->frame()->shouldThrottleRendering())
+  if (m_paintLayer.layoutObject().view()->frame() &&
+      m_paintLayer.layoutObject().view()->frame()->shouldThrottleRendering())
     return result;
 
   // Ensure our lists are up to date.
   m_paintLayer.stackingNode()->updateLayerListsIfNeeded();
 
   LayoutSize subpixelAccumulation =
       m_paintLayer.compositingState() == PaintsIntoOwnBacking
           ? m_paintLayer.subpixelAccumulation()
           : paintingInfoArg.subPixelAccumulation;
   ShouldRespectOverflowClipType respectOverflowClip =
@@ skipping 31 matching lines @@
     result = MayBeClippedByPaintDirtyRect;
 
   // These helpers output clip and compositing operations using a RAII pattern.
   // Stack-allocated-varibles are destructed in the reverse order of
   // construction, so they are nested properly.
   Optional<ClipPathClipper> clipPathClipper;
   // Clip-path, like border radius, must not be applied to the contents of a
   // composited-scrolling container.  It must, however, still be applied to the
   // mask layer, so that the compositor can properly mask the
   // scrolling contents and scrollbars.
-  if (m_paintLayer.layoutObject()->hasClipPath() &&
+  if (m_paintLayer.layoutObject().hasClipPath() &&
       (!m_paintLayer.needsCompositedScrolling() ||
        (paintFlags & (PaintLayerPaintingChildClippingMaskPhase |
                       PaintLayerPaintingAncestorClippingMaskPhase)))) {
     paintingInfo.ancestorHasClipPathClipping = true;
 
     LayoutRect referenceBox(m_paintLayer.boxForClipPath());
     // Note that this isn't going to work correctly if crossing a column
     // boundary. The reference box should be determined per-fragment, and hence
     // this ought to be performed after fragmentation.
     if (m_paintLayer.enclosingPaginationLayer())
       m_paintLayer.convertFromFlowThreadToVisualBoundingBoxInAncestor(
           paintingInfo.rootLayer, referenceBox);
     else
       referenceBox.moveBy(offsetFromRoot);
     clipPathClipper.emplace(
-        context, *m_paintLayer.layoutObject()->styleRef().clipPath(),
-        *m_paintLayer.layoutObject(), FloatRect(referenceBox),
+        context, *m_paintLayer.layoutObject().styleRef().clipPath(),
+        m_paintLayer.layoutObject(), FloatRect(referenceBox),
         FloatPoint(referenceBox.location()));
   }
 
   Optional<CompositingRecorder> compositingRecorder;
   // FIXME: this should be unified further into
   // PaintLayer::paintsWithTransparency().
   bool shouldCompositeForBlendMode =
       m_paintLayer.stackingNode()->isStackingContext() &&
       m_paintLayer.hasNonIsolatedDescendantWithBlendMode();
   if (shouldCompositeForBlendMode ||
       m_paintLayer.paintsWithTransparency(paintingInfo.getGlobalPaintFlags())) {
     FloatRect compositingBounds = FloatRect(m_paintLayer.paintingExtent(
         paintingInfo.rootLayer, paintingInfo.subPixelAccumulation,
         paintingInfo.getGlobalPaintFlags()));
     compositingRecorder.emplace(
-        context, *m_paintLayer.layoutObject(),
+        context, m_paintLayer.layoutObject(),
         WebCoreCompositeToSkiaComposite(
             CompositeSourceOver,
-            m_paintLayer.layoutObject()->style()->blendMode()),
-        m_paintLayer.layoutObject()->opacity(), &compositingBounds);
+            m_paintLayer.layoutObject().style()->blendMode()),
+        m_paintLayer.layoutObject().opacity(), &compositingBounds);
   }
 
   PaintLayerPaintingInfo localPaintingInfo(paintingInfo);
   localPaintingInfo.subPixelAccumulation = subpixelAccumulation;
 
   bool shouldPaintContent = m_paintLayer.hasVisibleContent() &&
                             isSelfPaintingLayer && !isPaintingOverlayScrollbars;
 
   PaintLayerFragments layerFragments;
   if (shouldPaintContent || shouldPaintSelfOutline ||
@@ skipping 73 matching lines @@
     }
   }
 
   Optional<ScopedPaintChunkProperties> contentScopedPaintChunkProperties;
   if (RuntimeEnabledFeatures::slimmingPaintV2Enabled() &&
       !scopedPaintChunkProperties.has_value()) {
     // If layoutObject() is a LayoutView and root layer scrolling is enabled,
     // the LayoutView's paint properties will already have been applied at
     // the top of this method, in scopedPaintChunkProperties.
     DCHECK(!(RuntimeEnabledFeatures::rootLayerScrollingEnabled() &&
-             m_paintLayer.layoutObject() &&
-             m_paintLayer.layoutObject()->isLayoutView()));
+             m_paintLayer.layoutObject().isLayoutView()));
     const auto* objectPaintProperties =
-        m_paintLayer.layoutObject()->paintProperties();
+        m_paintLayer.layoutObject().paintProperties();
     DCHECK(objectPaintProperties &&
            objectPaintProperties->localBorderBoxProperties());
     PaintChunkProperties properties(
         context.getPaintController().currentPaintChunkProperties());
     properties.propertyTreeState =
         *objectPaintProperties->localBorderBoxProperties();
-    properties.backfaceHidden =
-        m_paintLayer.layoutObject()->hasHiddenBackface();
+    properties.backfaceHidden = m_paintLayer.layoutObject().hasHiddenBackface();
     contentScopedPaintChunkProperties.emplace(context.getPaintController(),
                                               m_paintLayer, properties);
   }
 
   bool selectionOnly =
       localPaintingInfo.getGlobalPaintFlags() & GlobalPaintSelectionOnly;
   {  // Begin block for the lifetime of any filter.
     FilterPainter filterPainter(m_paintLayer, context, offsetFromRoot,
                                 layerFragments.isEmpty()
                                     ? ClipRect()
@@ skipping 44 matching lines @@
         result = MayBeClippedByPaintDirtyRect;
     }
 
     if (shouldPaintOverlayScrollbars)
       paintOverflowControlsForFragments(layerFragments, context,
                                         localPaintingInfo, paintFlags);
   }  // FilterPainter block
 
   bool shouldPaintMask =
       (paintFlags & PaintLayerPaintingCompositingMaskPhase) &&
-      shouldPaintContent && m_paintLayer.layoutObject()->hasMask() &&
+      shouldPaintContent && m_paintLayer.layoutObject().hasMask() &&
       !selectionOnly;
   bool shouldPaintClippingMask =
       (paintFlags & (PaintLayerPaintingChildClippingMaskPhase |
                      PaintLayerPaintingAncestorClippingMaskPhase)) &&
       shouldPaintContent && !selectionOnly;
 
   if (shouldPaintMask) {
     paintMaskForFragments(layerFragments, context, localPaintingInfo,
                           paintFlags);
   }
@@ skipping 43 matching lines @@
     // the layer.
     if (m_paintLayer.intersectsDamageRect(fragment.layerBounds,
                                           fragment.backgroundRect.rect(),
                                           newOffsetFromRoot))
       return true;
   }
   return false;
 }
 
 inline bool PaintLayerPainter::isFixedPositionObjectInPagedMedia() {
-  LayoutObject* object = m_paintLayer.layoutObject();
-  LayoutView* view = object->view();
-  return object->styleRef().position() == EPosition::kFixed &&
-         object->container() == view && view->pageLogicalHeight() &&
+  LayoutObject& object = m_paintLayer.layoutObject();
+  LayoutView* view = object.view();
+  return object.styleRef().position() == EPosition::kFixed &&
+         object.container() == view && view->pageLogicalHeight() &&
          // TODO(crbug.com/619094): Figure out the correct behaviour for fixed
          // position objects in paged media with vertical writing modes.
          view->isHorizontalWritingMode();
 }
 
 void PaintLayerPainter::repeatFixedPositionObjectInPages(
     const PaintLayerFragment& singleFragmentIgnoredPagination,
     const PaintLayerPaintingInfo& paintingInfo,
     PaintLayerFragments& layerFragments) {
   DCHECK(isFixedPositionObjectInPagedMedia());
 
-  LayoutView* view = m_paintLayer.layoutObject()->view();
+  LayoutView* view = m_paintLayer.layoutObject().view();
   unsigned pages =
       ceilf(view->documentRect().height() / view->pageLogicalHeight());
 
   // The fixed position object is offset from the top of the page, so remove
   // any scroll offset.
   LayoutPoint offsetFromRoot;
   m_paintLayer.convertToLayerCoords(paintingInfo.rootLayer, offsetFromRoot);
   LayoutSize offsetAdjustment = m_paintLayer.location() - offsetFromRoot;
   layerFragments.push_back(singleFragmentIgnoredPagination);
   layerFragments[0].paginationOffset += offsetAdjustment;
@@ skipping 96 matching lines @@
     if (parentLayer && !RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
       ClipRect clipRectForFragment(ancestorBackgroundClipRect);
       // A fixed-position object is repeated on every page instead of paginated,
       // so we should apply the original ancestor clip rect.
       if (!isFixedPositionObjectInPagedMedia)
         clipRectForFragment.moveBy(fragment.paginationOffset);
       clipRectForFragment.intersect(fragment.backgroundRect);
       if (clipRectForFragment.isEmpty())
         continue;
       if (needsToClip(paintingInfo, clipRectForFragment)) {
-        clipRecorder.emplace(context, *parentLayer->layoutObject(),
+        clipRecorder.emplace(context, parentLayer->layoutObject(),
                              DisplayItem::kClipLayerParent, clipRectForFragment,
                              paintingInfo.rootLayer, fragment.paginationOffset,
                              paintFlags);
       }
     }
     if (paintFragmentByApplyingTransform(context, paintingInfo, paintFlags,
                                          fragment.paginationOffset) ==
         MayBeClippedByPaintDirtyRect)
       result = MayBeClippedByPaintDirtyRect;
   }
@@ skipping 15 matching lines @@
       m_paintLayer.renderableTransform(paintingInfo.getGlobalPaintFlags()));
   IntPoint roundedDelta = roundedIntPoint(delta);
   transform.translateRight(roundedDelta.x(), roundedDelta.y());
   LayoutSize adjustedSubPixelAccumulation =
       paintingInfo.subPixelAccumulation + (delta - roundedDelta);
 
   // TODO(jbroman): Put the real transform origin here, instead of using a
   // matrix with the origin baked in.
   FloatPoint3D transformOrigin;
   Transform3DRecorder transform3DRecorder(
-      context, *m_paintLayer.layoutObject(),
+      context, m_paintLayer.layoutObject(),
       DisplayItem::kTransform3DElementTransform, transform, transformOrigin);
 
   // Now do a paint with the root layer shifted to be us.
   PaintLayerPaintingInfo transformedPaintingInfo(
       &m_paintLayer, LayoutRect(enclosingIntRect(transform.inverse().mapRect(
                          paintingInfo.paintDirtyRect))),
       paintingInfo.getGlobalPaintFlags(), adjustedSubPixelAccumulation);
   transformedPaintingInfo.ancestorHasClipPathClipping =
       paintingInfo.ancestorHasClipPathClipping;
 
@@ skipping 19 matching lines @@
 #endif
 
   PaintLayerStackingNodeIterator iterator(*m_paintLayer.stackingNode(),
                                           childrenToVisit);
   PaintLayerStackingNode* child = iterator.next();
   if (!child)
     return result;
 
   IntSize scrollOffsetAccumulationForChildren =
       paintingInfo.scrollOffsetAccumulation;
-  if (m_paintLayer.layoutObject()->hasOverflowClip())
+  if (m_paintLayer.layoutObject().hasOverflowClip())
     scrollOffsetAccumulationForChildren +=
         m_paintLayer.layoutBox()->scrolledContentOffset();
 
   for (; child; child = iterator.next()) {
     PaintLayerPainter childPainter(*child->layer());
     // If this Layer should paint into its own backing or a grouped backing,
     // that will be done via CompositedLayerMapping::paintContents() and
     // CompositedLayerMapping::doPaintTask().
     if (!childPainter.shouldPaintLayerInSoftwareMode(
             paintingInfo.getGlobalPaintFlags(), paintFlags))
       continue;
 
     PaintLayerPaintingInfo childPaintingInfo = paintingInfo;
     childPaintingInfo.scrollOffsetAccumulation =
         scrollOffsetAccumulationForChildren;
     // Rare case: accumulate scroll offset of non-stacking-context ancestors up
     // to m_paintLayer.
     for (PaintLayer* parentLayer = child->layer()->parent();
          parentLayer != &m_paintLayer; parentLayer = parentLayer->parent()) {
-      if (parentLayer->layoutObject()->hasOverflowClip())
+      if (parentLayer->layoutObject().hasOverflowClip())
         childPaintingInfo.scrollOffsetAccumulation +=
             parentLayer->layoutBox()->scrolledContentOffset();
     }
 
     if (childPainter.paint(context, childPaintingInfo, paintFlags) ==
         MayBeClippedByPaintDirtyRect)
       result = MayBeClippedByPaintDirtyRect;
   }
 
   return result;
@@ skipping 21 matching lines @@
   if (layerFragments.size() > 1)
     cacheSkipper.emplace(context);
 
   for (auto& fragment : layerFragments) {
     // We need to apply the same clips and transforms that
     // paintFragmentWithPhase would have.
     LayoutRect cullRect = fragment.backgroundRect.rect();
 
     Optional<LayerClipRecorder> clipRecorder;
     if (needsToClip(localPaintingInfo, fragment.backgroundRect)) {
-      clipRecorder.emplace(context, *m_paintLayer.layoutObject(),
+      clipRecorder.emplace(context, m_paintLayer.layoutObject(),
                            DisplayItem::kClipLayerOverflowControls,
                            fragment.backgroundRect, localPaintingInfo.rootLayer,
                            fragment.paginationOffset, paintFlags);
     }
 
     Optional<ScrollRecorder> scrollRecorder;
     if (!RuntimeEnabledFeatures::slimmingPaintV2Enabled() &&
         !localPaintingInfo.scrollOffsetAccumulation.isZero()) {
       cullRect.move(localPaintingInfo.scrollOffsetAccumulation);
-      scrollRecorder.emplace(context, *m_paintLayer.layoutObject(),
+      scrollRecorder.emplace(context, m_paintLayer.layoutObject(),
                              DisplayItem::kScrollOverflowControls,
                              localPaintingInfo.scrollOffsetAccumulation);
     }
 
     // We pass IntPoint() as the paint offset here, because
     // ScrollableArea::paintOverflowControls just ignores it and uses the
     // offset found in a previous pass.
     CullRect snappedCullRect(pixelSnappedIntRect(cullRect));
     ScrollableAreaPainter(*scrollableArea)
         .paintOverflowControls(context, IntPoint(), snappedCullRect, true);
@@ skipping 24 matching lines @@
         clippingRule = LayerClipRecorder::DoNotIncludeSelfForBorderRadius;
         break;
       default:
         clippingRule = LayerClipRecorder::IncludeSelfForBorderRadius;
         break;
     }
 
     // TODO(schenney): Nested border-radius clips are not applied to composited
     // children, probably due to an incorrect clipRoot.
     // https://bugs.chromium.org/p/chromium/issues/detail?id=672561
-    clipRecorder.emplace(context, *m_paintLayer.layoutObject(), clipType,
+    clipRecorder.emplace(context, m_paintLayer.layoutObject(), clipType,
                          clipRect, paintingInfo.rootLayer,
                          fragment.paginationOffset, paintFlags, clippingRule);
   }
 
   // If we are painting a mask for any reason and we have already processed the
   // clips, there is no need to go through the remaining painting pipeline.
   // We know that the mask just needs the area bounded by the clip rects to be
   // filled with black.
   if (clipRecorder && phase == PaintPhaseClippingMask) {
     fillMaskingFragment(context, clipRect);
     return;
   }
 
   LayoutRect newCullRect(clipRect.rect());
   Optional<ScrollRecorder> scrollRecorder;
   LayoutPoint paintOffset = -m_paintLayer.layoutBoxLocation();
   if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
     const auto* objectPaintProperties =
-        m_paintLayer.layoutObject()->paintProperties();
+        m_paintLayer.layoutObject().paintProperties();
     DCHECK(objectPaintProperties &&
            objectPaintProperties->localBorderBoxProperties());
-    paintOffset += m_paintLayer.layoutObject()->paintOffset();
+    paintOffset += m_paintLayer.layoutObject().paintOffset();
     newCullRect.move(paintingInfo.scrollOffsetAccumulation);
   } else {
     paintOffset += toSize(fragment.layerBounds.location());
     if (!paintingInfo.scrollOffsetAccumulation.isZero()) {
       // As a descendant of the root layer, m_paintLayer's painting is not
       // controlled by the ScrollRecorders created by BlockPainter of the
       // ancestor layers up to the root layer, so we need to issue
       // ScrollRecorder for this layer seperately, with the scroll offset
       // accumulated from the root layer to the parent of this layer, to get the
       // same result as ScrollRecorder in BlockPainter.
       paintOffset += paintingInfo.scrollOffsetAccumulation;
 
       newCullRect.move(paintingInfo.scrollOffsetAccumulation);
-      scrollRecorder.emplace(context, *m_paintLayer.layoutObject(), phase,
+      scrollRecorder.emplace(context, m_paintLayer.layoutObject(), phase,
                              paintingInfo.scrollOffsetAccumulation);
     }
   }
   PaintInfo paintInfo(context, pixelSnappedIntRect(newCullRect), phase,
                       paintingInfo.getGlobalPaintFlags(), paintFlags,
-                      paintingInfo.rootLayer->layoutObject());
+                      &paintingInfo.rootLayer->layoutObject());
 
-  m_paintLayer.layoutObject()->paint(paintInfo, paintOffset);
+  m_paintLayer.layoutObject().paint(paintInfo, paintOffset);
 }
 
 void PaintLayerPainter::paintBackgroundForFragments(
     const PaintLayerFragments& layerFragments,
     GraphicsContext& context,
     const LayoutRect& transparencyPaintDirtyRect,
     const PaintLayerPaintingInfo& localPaintingInfo,
     PaintLayerFlags paintFlags) {
   Optional<DisplayItemCacheSkipper> cacheSkipper;
   if (layerFragments.size() > 1)
@@ skipping 15 matching lines @@
   DCHECK(!(paintFlags & PaintLayerPaintingRootBackgroundOnly));
 
   // Optimize clipping for the single fragment case.
   bool shouldClip = localPaintingInfo.clipToDirtyRect &&
                     layerFragments.size() == 1 &&
                     !layerFragments[0].foregroundRect.isEmpty();
   ClipState clipState = HasNotClipped;
   Optional<LayerClipRecorder> clipRecorder;
   if (shouldClip &&
       needsToClip(localPaintingInfo, layerFragments[0].foregroundRect)) {
-    clipRecorder.emplace(context, *m_paintLayer.layoutObject(),
-                         DisplayItem::kClipLayerForeground,
-                         layerFragments[0].foregroundRect,
-                         localPaintingInfo.rootLayer,
-                         layerFragments[0].paginationOffset, paintFlags);
+    clipRecorder.emplace(
+        context, m_paintLayer.layoutObject(), DisplayItem::kClipLayerForeground,
+        layerFragments[0].foregroundRect, localPaintingInfo.rootLayer,
+        layerFragments[0].paginationOffset, paintFlags);
     clipState = HasClipped;
   }
 
   // We have to loop through every fragment multiple times, since we have to
   // issue paint invalidations in each specific phase in order for interleaving
   // of the fragments to work properly.
   if (selectionOnly) {
     paintForegroundForFragmentsWithPhase(PaintPhaseSelection, layerFragments,
                                          context, localPaintingInfo, paintFlags,
                                          clipState);
@@ skipping 91 matching lines @@
     GraphicsContext& context,
     const PaintLayerPaintingInfo& localPaintingInfo,
     PaintLayerFlags paintFlags) {
   Optional<DisplayItemCacheSkipper> cacheSkipper;
   if (layerFragments.size() > 1)
     cacheSkipper.emplace(context);
 
   Optional<ScopedPaintChunkProperties> scopedPaintChunkProperties;
   if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
     const auto* objectPaintProperties =
-        m_paintLayer.layoutObject()->paintProperties();
+        m_paintLayer.layoutObject().paintProperties();
     DCHECK(objectPaintProperties && objectPaintProperties->mask());
     PaintChunkProperties properties(
         context.getPaintController().currentPaintChunkProperties());
     properties.propertyTreeState.setEffect(objectPaintProperties->mask());
     scopedPaintChunkProperties.emplace(context.getPaintController(),
                                        m_paintLayer, properties);
   }
 
   for (auto& fragment : layerFragments)
     paintFragmentWithPhase(PaintPhaseMask, fragment, context,
@@ skipping 26 matching lines @@
   PaintLayerPaintingInfo paintingInfo(&m_paintLayer,
                                       LayoutRect(enclosingIntRect(damageRect)),
                                       paintFlags, LayoutSize());
   paint(context, paintingInfo, PaintLayerPaintingOverlayScrollbars);
 
   m_paintLayer.setContainsDirtyOverlayScrollbars(false);
 }
 
 void PaintLayerPainter::fillMaskingFragment(GraphicsContext& context,
                                             const ClipRect& clipRect) {
-  const LayoutObject& layoutObject = *m_paintLayer.layoutObject();
+  const LayoutObject& layoutObject = m_paintLayer.layoutObject();
   if (LayoutObjectDrawingRecorder::useCachedDrawingIfPossible(
           context, layoutObject, PaintPhaseClippingMask))
     return;
 
   IntRect snappedClipRect = pixelSnappedIntRect(clipRect.rect());
   LayoutObjectDrawingRecorder drawingRecorder(
       context, layoutObject, PaintPhaseClippingMask, snappedClipRect);
   context.fillRect(snappedClipRect, Color::black);
 }
 
 }  // namespace blink