Change PaintLayer::m_layoutObject to a reference.

third_party/WebKit/Source/core/layout/compositing/CompositedLayerMapping.cpp

 /*
  * Copyright (C) 2009, 2010, 2011 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 66 matching lines @@
 #include "platform/graphics/paint/PaintRecordBuilder.h"
 #include "platform/graphics/paint/TransformDisplayItem.h"
 #include "public/platform/WebLayerStickyPositionConstraint.h"
 #include "wtf/CurrentTime.h"
 #include "wtf/text/StringBuilder.h"
 
 namespace blink {
 
 using namespace HTMLNames;
 
-static IntRect clipBox(LayoutBox* layoutObject);
+static IntRect clipBox(LayoutBox& layoutObject);
 
-static IntRect contentsRect(const LayoutObject* layoutObject) {
-  if (!layoutObject->isBox())
+static IntRect contentsRect(const LayoutObject& layoutObject) {
+  if (!layoutObject.isBox())
     return IntRect();
-  if (layoutObject->isCanvas())
+  if (layoutObject.isCanvas()) {
     return pixelSnappedIntRect(
-        toLayoutHTMLCanvas(layoutObject)->replacedContentRect());
-  if (layoutObject->isVideo())
+        toLayoutHTMLCanvas(layoutObject).replacedContentRect());
+  }
+  if (layoutObject.isVideo()) {
     return pixelSnappedIntRect(
-        toLayoutVideo(layoutObject)->replacedContentRect());
+        toLayoutVideo(layoutObject).replacedContentRect());
+  }
 
-  return pixelSnappedIntRect(toLayoutBox(layoutObject)->contentBoxRect());
+  return pixelSnappedIntRect(toLayoutBox(layoutObject).contentBoxRect());
 }
 
-static IntRect backgroundRect(const LayoutObject* layoutObject) {
-  if (!layoutObject->isBox())
+static IntRect backgroundRect(const LayoutObject& layoutObject) {
+  if (!layoutObject.isBox())
     return IntRect();
 
   LayoutRect rect;
-  const LayoutBox* box = toLayoutBox(layoutObject);
-  return pixelSnappedIntRect(box->backgroundRect(BackgroundClipRect));
+  const LayoutBox& box = toLayoutBox(layoutObject);
+  return pixelSnappedIntRect(box.backgroundRect(BackgroundClipRect));
 }
 
-static inline bool isAcceleratedCanvas(const LayoutObject* layoutObject) {
-  if (layoutObject->isCanvas()) {
-    HTMLCanvasElement* canvas = toHTMLCanvasElement(layoutObject->node());
+static inline bool isAcceleratedCanvas(const LayoutObject& layoutObject) {
+  if (layoutObject.isCanvas()) {
+    HTMLCanvasElement* canvas = toHTMLCanvasElement(layoutObject.node());
     if (CanvasRenderingContext* context = canvas->renderingContext())
       return context->isAccelerated();
   }
   return false;
 }
 
 static inline bool isCanvasControlledByOffscreen(
-    const LayoutObject* layoutObject) {
-  if (layoutObject->isCanvas()) {
-    HTMLCanvasElement* canvas = toHTMLCanvasElement(layoutObject->node());
+    const LayoutObject& layoutObject) {
+  if (layoutObject.isCanvas()) {
+    HTMLCanvasElement* canvas = toHTMLCanvasElement(layoutObject.node());
     if (canvas->surfaceLayerBridge())
       return true;
   }
   return false;
 }
 
 static bool hasBoxDecorationsOrBackgroundImage(const ComputedStyle& style) {
   return style.hasBoxDecorations() || style.hasBackgroundImage();
 }
 
 static bool contentLayerSupportsDirectBackgroundComposition(
-    const LayoutObject* layoutObject) {
+    const LayoutObject& layoutObject) {
   // No support for decorations - border, border-radius or outline.
   // Only simple background - solid color or transparent.
-  if (hasBoxDecorationsOrBackgroundImage(layoutObject->styleRef()))
+  if (hasBoxDecorationsOrBackgroundImage(layoutObject.styleRef()))
     return false;
 
   // If there is no background, there is nothing to support.
-  if (!layoutObject->style()->hasBackground())
+  if (!layoutObject.style()->hasBackground())
     return true;
 
   // Simple background that is contained within the contents rect.
   return contentsRect(layoutObject).contains(backgroundRect(layoutObject));
 }
 
-static WebLayer* platformLayerForPlugin(LayoutObject* layoutObject) {
-  if (!layoutObject->isEmbeddedObject())
+static WebLayer* platformLayerForPlugin(LayoutObject& layoutObject) {
+  if (!layoutObject.isEmbeddedObject())
     return nullptr;
-  Widget* widget = toLayoutEmbeddedObject(layoutObject)->widget();
+  Widget* widget = toLayoutEmbeddedObject(layoutObject).widget();
   if (!widget || !widget->isPluginView())
     return nullptr;
   return toPluginView(widget)->platformLayer();
 }
 
-static inline bool isAcceleratedContents(LayoutObject* layoutObject) {
+static inline bool isAcceleratedContents(LayoutObject& layoutObject) {
   return isAcceleratedCanvas(layoutObject) ||
-         (layoutObject->isEmbeddedObject() &&
+         (layoutObject.isEmbeddedObject() &&
           toLayoutEmbeddedObject(layoutObject)
-              ->requiresAcceleratedCompositing()) ||
-         layoutObject->isVideo();
+              .requiresAcceleratedCompositing()) ||
+         layoutObject.isVideo();
 }
 
 // Get the scrolling coordinator in a way that works inside
 // CompositedLayerMapping's destructor.
 static ScrollingCoordinator* scrollingCoordinatorFromLayer(PaintLayer& layer) {
-  Page* page = layer.layoutObject()->frame()->page();
+  Page* page = layer.layoutObject().frame()->page();
   return (!page) ? nullptr : page->scrollingCoordinator();
 }
 
 CompositedLayerMapping::CompositedLayerMapping(PaintLayer& layer)
     : m_owningLayer(layer),
       m_contentOffsetInCompositingLayerDirty(false),
       m_pendingUpdateScope(GraphicsLayerUpdateNone),
       m_isMainFrameLayoutViewLayer(false),
       m_backgroundLayerPaintsFixedRootBackground(false),
       m_scrollingContentsAreEmpty(false),
       m_backgroundPaintsOntoScrollingContentsLayer(false),
       m_backgroundPaintsOntoGraphicsLayer(false),
       m_drawsBackgroundOntoContentLayer(false) {
-  if (layer.isRootLayer() && layoutObject()->frame()->isMainFrame())
+  if (layer.isRootLayer() && layoutObject().frame()->isMainFrame())
     m_isMainFrameLayoutViewLayer = true;
 
   createPrimaryGraphicsLayer();
 }
 
 CompositedLayerMapping::~CompositedLayerMapping() {
   // Hits in compositing/squashing/squash-onto-nephew.html.
   DisableCompositingQueryAsserts disabler;
 
   // Do not leave the destroyed pointer dangling on any Layers that painted to
@@ skipping 21 matching lines @@
   destroyGraphicsLayers();
 }
 
 std::unique_ptr<GraphicsLayer> CompositedLayerMapping::createGraphicsLayer(
     CompositingReasons reasons,
     SquashingDisallowedReasons squashingDisallowedReasons) {
   std::unique_ptr<GraphicsLayer> graphicsLayer = GraphicsLayer::create(this);
 
   graphicsLayer->setCompositingReasons(reasons);
   graphicsLayer->setSquashingDisallowedReasons(squashingDisallowedReasons);
-  if (Node* owningNode = m_owningLayer.layoutObject()->node())
+  if (Node* owningNode = m_owningLayer.layoutObject().node())
     graphicsLayer->setOwnerNodeId(DOMNodeIds::idForNode(owningNode));
 
   return graphicsLayer;
 }
 
 void CompositedLayerMapping::createPrimaryGraphicsLayer() {
   m_graphicsLayer =
       createGraphicsLayer(m_owningLayer.getCompositingReasons(),
                           m_owningLayer.getSquashingDisallowedReasons());
 
-  updateOpacity(layoutObject()->styleRef());
-  updateTransform(layoutObject()->styleRef());
-  updateFilters(layoutObject()->styleRef());
-  updateBackdropFilters(layoutObject()->styleRef());
-  updateLayerBlendMode(layoutObject()->styleRef());
+  updateOpacity(layoutObject().styleRef());
+  updateTransform(layoutObject().styleRef());
+  updateFilters(layoutObject().styleRef());
+  updateBackdropFilters(layoutObject().styleRef());
+  updateLayerBlendMode(layoutObject().styleRef());
   updateIsRootForIsolatedGroup();
 }
 
 void CompositedLayerMapping::destroyGraphicsLayers() {
   if (m_graphicsLayer)
     m_graphicsLayer->removeFromParent();
 
   m_ancestorClippingLayer = nullptr;
   m_ancestorClippingMaskLayer = nullptr;
   m_graphicsLayer = nullptr;
@@ skipping 11 matching lines @@
 void CompositedLayerMapping::updateOpacity(const ComputedStyle& style) {
   m_graphicsLayer->setOpacity(compositingOpacity(style.opacity()));
 }
 
 void CompositedLayerMapping::updateTransform(const ComputedStyle& style) {
   // FIXME: This could use m_owningLayer.transform(), but that currently has
   // transform-origin baked into it, and we don't want that.
   TransformationMatrix t;
   if (m_owningLayer.hasTransformRelatedProperty()) {
     style.applyTransform(
-        t, LayoutSize(toLayoutBox(layoutObject())->pixelSnappedSize()),
+        t, LayoutSize(toLayoutBox(layoutObject()).pixelSnappedSize()),
         ComputedStyle::ExcludeTransformOrigin, ComputedStyle::IncludeMotionPath,
         ComputedStyle::IncludeIndependentTransformProperties);
     makeMatrixRenderable(t, compositor()->hasAcceleratedCompositing());
   }
 
   m_graphicsLayer->setTransform(t);
 }
 
 void CompositedLayerMapping::updateFilters(const ComputedStyle& style) {
   m_graphicsLayer->setFilters(
       owningLayer().createCompositorFilterOperationsForFilter(style));
 }
 
 void CompositedLayerMapping::updateBackdropFilters(const ComputedStyle& style) {
   m_graphicsLayer->setBackdropFilters(
       owningLayer().createCompositorFilterOperationsForBackdropFilter(style));
 }
 
 void CompositedLayerMapping::updateStickyConstraints(
     const ComputedStyle& style) {
   bool sticky = style.position() == EPosition::kSticky;
   const PaintLayer* ancestorOverflowLayer =
       m_owningLayer.ancestorOverflowLayer();
   // TODO(flackr): Do we still need this?
   if (sticky) {
     if (!ancestorOverflowLayer->isRootLayer()) {
       sticky = ancestorOverflowLayer->needsCompositedScrolling();
     } else {
-      sticky = layoutObject()->view()->frameView()->isScrollable();
+      sticky = layoutObject().view()->frameView()->isScrollable();
     }
   }
 
   WebLayerStickyPositionConstraint webConstraint;
   if (sticky) {
     const StickyPositionScrollingConstraints& constraints =
         ancestorOverflowLayer->getScrollableArea()->stickyConstraintsMap().get(
             &m_owningLayer);
 
     // Find the layout offset of the unshifted sticky box within its enclosing
@@ skipping 75 matching lines @@
     m_backgroundPaintsOntoGraphicsLayer = shouldPaintOntoGraphicsLayer;
     // The graphics layer needs to be updated for changed
     // m_backgroundPaintsOntoGraphicsLayer.
     m_graphicsLayer->setNeedsDisplay();
   }
 }
 
 void CompositedLayerMapping::updateContentsOpaque() {
   if (isAcceleratedCanvas(layoutObject())) {
     CanvasRenderingContext* context =
-        toHTMLCanvasElement(layoutObject()->node())->renderingContext();
+        toHTMLCanvasElement(layoutObject().node())->renderingContext();
     WebLayer* layer = context ? context->platformLayer() : nullptr;
     // Determine whether the external texture layer covers the whole graphics
     // layer. This may not be the case if there are box decorations or
     // shadows.
     if (layer &&
         layer->bounds() == m_graphicsLayer->platformLayer()->bounds()) {
       // Determine whether the rendering context's external texture layer is
       // opaque.
       if (!context->creationAttributes().alpha()) {
         m_graphicsLayer->setContentsOpaque(true);
@@ skipping 13 matching lines @@
     // layer if all backgrounds are background attachment local, otherwise
     // background is painted by the primary graphics layer.
     if (hasScrollingLayer() && m_backgroundPaintsOntoScrollingContentsLayer) {
       // Backgrounds painted onto the foreground are clipped by the padding box
       // rect.
       // TODO(flackr): This should actually check the entire overflow rect
       // within the scrolling contents layer but since we currently only trigger
       // this for solid color backgrounds the answer will be the same.
       m_scrollingContentsLayer->setContentsOpaque(
           m_owningLayer.backgroundIsKnownToBeOpaqueInRect(
-              toLayoutBox(layoutObject())->paddingBoxRect()));
+              toLayoutBox(layoutObject()).paddingBoxRect()));
 
       if (m_owningLayer.backgroundPaintLocation() &
           BackgroundPaintInGraphicsLayer) {
         m_graphicsLayer->setContentsOpaque(
             m_owningLayer.backgroundIsKnownToBeOpaqueInRect(
                 compositedBounds()));
       } else {
         // If we only paint the background onto the scrolling contents layer we
         // are going to leave a hole in the m_graphicsLayer where the background
         // is so it is not opaque.
@@ skipping 11 matching lines @@
 void CompositedLayerMapping::updateCompositedBounds() {
   ASSERT(m_owningLayer.compositor()->lifecycle().state() ==
          DocumentLifecycle::InCompositingUpdate);
   // FIXME: if this is really needed for performance, it would be better to
   // store it on Layer.
   m_compositedBounds = m_owningLayer.boundingBoxForCompositing();
   m_contentOffsetInCompositingLayerDirty = true;
 }
 
 void CompositedLayerMapping::updateAfterPartResize() {
-  if (layoutObject()->isLayoutPart()) {
+  if (layoutObject().isLayoutPart()) {
     if (PaintLayerCompositor* innerCompositor =
             PaintLayerCompositor::frameContentsCompositor(
                 toLayoutPart(layoutObject()))) {
       innerCompositor->frameViewDidChangeSize();
       // We can floor this point because our frameviews are always aligned to
       // pixel boundaries.
       ASSERT(m_compositedBounds.location() ==
              flooredIntPoint(m_compositedBounds.location()));
       innerCompositor->frameViewDidChangeLocation(
           flooredIntPoint(contentsBox().location()));
     }
   }
 }
 
 void CompositedLayerMapping::updateCompositingReasons() {
   // All other layers owned by this mapping will have the same compositing
   // reason for their lifetime, so they are initialized only when created.
   m_graphicsLayer->setCompositingReasons(m_owningLayer.getCompositingReasons());
   m_graphicsLayer->setSquashingDisallowedReasons(
       m_owningLayer.getSquashingDisallowedReasons());
 }
 
 bool CompositedLayerMapping::ancestorRoundedCornersWontClip(
-    const LayoutObject* child,
-    const LayoutObject* clippingAncestor) {
-  if (!clippingAncestor->isBoxModelObject())
-    return false;
-  const LayoutBoxModelObject* clippingObject =
-      toLayoutBoxModelObject(clippingAncestor);
+    const LayoutBoxModelObject& child,
+    const LayoutBoxModelObject& clippingAncestor) {
   LayoutRect localVisualRect = m_compositedBounds;
-  child->mapToVisualRectInAncestorSpace(clippingObject, localVisualRect);
+  child.mapToVisualRectInAncestorSpace(&clippingAncestor, localVisualRect);
   FloatRoundedRect roundedClipRect =
-      clippingObject->style()->getRoundedInnerBorderFor(
-          clippingObject->localVisualRect());
+      clippingAncestor.style()->getRoundedInnerBorderFor(
+          clippingAncestor.localVisualRect());
   FloatRect innerClipRect = roundedClipRect.radiusCenterRect();
   // The first condition catches cases where the child is certainly inside
   // the rounded corner portion of the border, and cannot be clipped by
   // the rounded portion. The second catches cases where the child is
   // entirely outside the rectangular border (ignoring rounded corners) so
   // is also unaffected by the rounded corners. In both cases the existing
   // rectangular clip is adequate and the mask is unnecessary.
   return innerClipRect.contains(FloatRect(localVisualRect)) ||
          !localVisualRect.intersects(
              enclosingLayoutRect(roundedClipRect.rect()));
 }
 
 void CompositedLayerMapping::
     owningLayerClippedOrMaskedByLayerNotAboveCompositedAncestor(
         const PaintLayer* scrollParent,
         bool& owningLayerIsClipped,
         bool& owningLayerIsMasked) {
   owningLayerIsClipped = false;
   owningLayerIsMasked = false;
 
   if (!m_owningLayer.parent())
     return;
 
   const PaintLayer* compositingAncestor =
       m_owningLayer.enclosingLayerWithCompositedLayerMapping(ExcludeSelf);
   if (!compositingAncestor)
     return;
 
-  const LayoutObject* clippingContainer = m_owningLayer.clippingContainer();
+  const LayoutBoxModelObject* clippingContainer =
+      m_owningLayer.clippingContainer();
   if (!clippingContainer)
     return;
 
   if (clippingContainer->enclosingLayer() == scrollParent)
     return;
 
   if (clippingContainer->enclosingLayer()->hasRootScrollerAsDescendant())
     return;
 
-  if (compositingAncestor->layoutObject()->isDescendantOf(clippingContainer))
+  if (compositingAncestor->layoutObject().isDescendantOf(clippingContainer))
     return;
 
   // We ignore overflow clip here; we want composited overflow content to
   // behave as if it lives in an unclipped universe so it can prepaint, etc.
   // This means that we need to check if we are actually clipped before
   // setting up m_ancestorClippingLayer otherwise
   // updateAncestorClippingLayerGeometry will fail as the clip rect will be
   // infinite.
   // FIXME: this should use cached clip rects, but this sometimes give
   // inaccurate results (and trips the ASSERTS in PaintLayerClipper).
   ClipRectsContext clipRectsContext(compositingAncestor, UncachedClipRects,
                                     IgnoreOverlayScrollbarSize);
   clipRectsContext.setIgnoreOverflowClip();
   LayoutRect unsnappedParentClipRect =
       m_owningLayer.clipper(PaintLayer::DoNotUseGeometryMapper)
           .backgroundClipRect(clipRectsContext)
           .rect();
   IntRect parentClipRect = pixelSnappedIntRect(unsnappedParentClipRect);
   owningLayerIsClipped = parentClipRect != LayoutRect::infiniteIntRect();
 
   // TODO(schenney): CSS clips are not applied to composited children, and
   // should be via mask or by compositing the parent too.
   // https://bugs.chromium.org/p/chromium/issues/detail?id=615870
   DCHECK(clippingContainer->style());
   owningLayerIsMasked =
       owningLayerIsClipped && clippingContainer->style()->hasBorderRadius() &&
-      !ancestorRoundedCornersWontClip(layoutObject(), clippingContainer);
+      !ancestorRoundedCornersWontClip(layoutObject(), *clippingContainer);
 }
 
 const PaintLayer* CompositedLayerMapping::scrollParent() {
   const PaintLayer* scrollParent = m_owningLayer.scrollParent();
   if (scrollParent && !scrollParent->needsCompositedScrolling())
     return nullptr;
   return scrollParent;
 }
 
 bool CompositedLayerMapping::updateGraphicsLayerConfiguration() {
   ASSERT(m_owningLayer.compositor()->lifecycle().state() ==
          DocumentLifecycle::InCompositingUpdate);
 
   // Note carefully: here we assume that the compositing state of all
   // descendants have been updated already, so it is legitimate to compute and
   // cache the composited bounds for this layer.
   updateCompositedBounds();
 
   PaintLayerCompositor* compositor = this->compositor();
-  LayoutObject* layoutObject = this->layoutObject();
-  const ComputedStyle& style = layoutObject->styleRef();
+  LayoutObject& layoutObject = this->layoutObject();
+  const ComputedStyle& style = layoutObject.styleRef();
 
   bool layerConfigChanged = false;
   setBackgroundLayerPaintsFixedRootBackground(
       compositor->needsFixedRootBackgroundLayer(&m_owningLayer));
 
   // The background layer is currently only used for fixed root backgrounds.
   if (updateBackgroundLayer(m_backgroundLayerPaintsFixedRootBackground))
     layerConfigChanged = true;
 
   if (updateForegroundLayer(
@@ skipping 31 matching lines @@
 
   bool scrollingConfigChanged = false;
   if (updateScrollingLayers(m_owningLayer.needsCompositedScrolling())) {
     layerConfigChanged = true;
     scrollingConfigChanged = true;
   }
 
   // If the outline needs to draw over the composited scrolling contents layer
   // or scrollbar layers it needs to be drawn into a separate layer.
   int minBorderWidth =
-      std::min(layoutObject->style()->borderTopWidth(),
-               std::min(layoutObject->style()->borderLeftWidth(),
-                        std::min(layoutObject->style()->borderRightWidth(),
-                                 layoutObject->style()->borderBottomWidth())));
+      std::min(layoutObject.style()->borderTopWidth(),
+               std::min(layoutObject.style()->borderLeftWidth(),
+                        std::min(layoutObject.style()->borderRightWidth(),
+                                 layoutObject.style()->borderBottomWidth())));
   bool needsDecorationOutlineLayer =
       m_owningLayer.getScrollableArea() &&
       m_owningLayer.getScrollableArea()->usesCompositedScrolling() &&
-      layoutObject->style()->hasOutline() &&
-      layoutObject->style()->outlineOffset() < -minBorderWidth;
+      layoutObject.style()->hasOutline() &&
+      layoutObject.style()->outlineOffset() < -minBorderWidth;
 
   if (updateDecorationOutlineLayer(needsDecorationOutlineLayer))
     layerConfigChanged = true;
 
   if (updateOverflowControlsLayers(
           requiresHorizontalScrollbarLayer(), requiresVerticalScrollbarLayer(),
           requiresScrollCornerLayer(), needsAncestorClip))
     layerConfigChanged = true;
 
   bool hasPerspective = style.hasPerspective();
-  bool needsChildTransformLayer = hasPerspective && layoutObject->isBox();
+  bool needsChildTransformLayer = hasPerspective && layoutObject.isBox();
   if (updateChildTransformLayer(needsChildTransformLayer))
     layerConfigChanged = true;
 
   if (updateSquashingLayers(!m_squashedLayers.isEmpty()))
     layerConfigChanged = true;
 
   updateScrollParent(scrollParent);
   updateClipParent(scrollParent);
 
   if (layerConfigChanged)
     updateInternalHierarchy();
 
   if (scrollingConfigChanged) {
-    if (layoutObject->view())
+    if (layoutObject.view())
       compositor->scrollingLayerDidChange(&m_owningLayer);
   }
 
   // A mask layer is not part of the hierarchy proper, it's an auxiliary layer
   // that's plugged into another GraphicsLayer that is part of the hierarchy.
   // It has no parent or child GraphicsLayer. For that reason, we process it
   // here, after the hierarchy has been updated.
-  bool maskLayerChanged = updateMaskLayer(layoutObject->hasMask());
+  bool maskLayerChanged = updateMaskLayer(layoutObject.hasMask());
   if (maskLayerChanged)
     m_graphicsLayer->setMaskLayer(m_maskLayer.get());
 
   bool hasChildClippingLayer =
       compositor->clipsCompositingDescendants(&m_owningLayer) &&
       (hasClippingLayer() || hasScrollingLayer());
   // If we have a border radius or clip path on a scrolling layer, we need a
   // clipping mask to properly clip the scrolled contents, even if there are no
   // composited descendants.
   bool hasClipPath = style.clipPath();
@@ skipping 39 matching lines @@
     scrollingLayer()->setMaskLayer(layerToApplyChildClippingMask ==
                                            scrollingLayer()
                                        ? m_childClippingMaskLayer.get()
                                        : nullptr);
   m_graphicsLayer->setContentsClippingMaskLayer(
       shouldApplyChildClippingMaskOnContents ? m_childClippingMaskLayer.get()
                                              : nullptr);
 
   updateBackgroundColor();
 
-  if (layoutObject->isImage()) {
+  if (layoutObject.isImage()) {
     if (isDirectlyCompositedImage()) {
       updateImageContents();
     } else if (m_graphicsLayer->hasContentsLayer()) {
       m_graphicsLayer->setContentsToImage(nullptr);
     }
   }
 
   if (WebLayer* layer = platformLayerForPlugin(layoutObject)) {
     m_graphicsLayer->setContentsToPlatformLayer(layer);
-  } else if (layoutObject->node() &&
-             layoutObject->node()->isFrameOwnerElement() &&
-             toHTMLFrameOwnerElement(layoutObject->node())->contentFrame()) {
-    Frame* frame =
-        toHTMLFrameOwnerElement(layoutObject->node())->contentFrame();
+  } else if (layoutObject.node() &&
+             layoutObject.node()->isFrameOwnerElement() &&
+             toHTMLFrameOwnerElement(layoutObject.node())->contentFrame()) {
+    Frame* frame = toHTMLFrameOwnerElement(layoutObject.node())->contentFrame();
     if (frame->isRemoteFrame()) {
       WebLayer* layer = toRemoteFrame(frame)->webLayer();
       m_graphicsLayer->setContentsToPlatformLayer(layer);
     }
-  } else if (layoutObject->isVideo()) {
-    HTMLMediaElement* mediaElement = toHTMLMediaElement(layoutObject->node());
+  } else if (layoutObject.isVideo()) {
+    HTMLMediaElement* mediaElement = toHTMLMediaElement(layoutObject.node());
     m_graphicsLayer->setContentsToPlatformLayer(mediaElement->platformLayer());
   } else if (isCanvasControlledByOffscreen(layoutObject)) {
-    HTMLCanvasElement* canvas = toHTMLCanvasElement(layoutObject->node());
+    HTMLCanvasElement* canvas = toHTMLCanvasElement(layoutObject.node());
     m_graphicsLayer->setContentsToPlatformLayer(
         canvas->surfaceLayerBridge()->getWebLayer());
     layerConfigChanged = true;
   } else if (isAcceleratedCanvas(layoutObject)) {
-    HTMLCanvasElement* canvas = toHTMLCanvasElement(layoutObject->node());
+    HTMLCanvasElement* canvas = toHTMLCanvasElement(layoutObject.node());
     if (CanvasRenderingContext* context = canvas->renderingContext())
       m_graphicsLayer->setContentsToPlatformLayer(context->platformLayer());
     layerConfigChanged = true;
   }
-  if (layoutObject->isLayoutPart()) {
+  if (layoutObject.isLayoutPart()) {
     if (PaintLayerCompositor::attachFrameContentLayersToIframeLayer(
             toLayoutPart(layoutObject)))
       layerConfigChanged = true;
   }
 
   // Changes to either the internal hierarchy or the mask layer have an impact
   // on painting phases, so we need to update when either are updated.
   if (layerConfigChanged || maskLayerChanged)
     updatePaintingPhases();
 
   updateElementIdAndCompositorMutableProperties();
 
   m_graphicsLayer->setHasWillChangeTransformHint(
       style.hasWillChangeTransformHint());
 
   if (style.preserves3D() && style.hasOpacity() &&
       m_owningLayer.has3DTransformedDescendant())
-    UseCounter::count(layoutObject->document(),
+    UseCounter::count(layoutObject.document(),
                       UseCounter::OpacityWithPreserve3DQuirk);
 
   return layerConfigChanged;
 }
 
-static IntRect clipBox(LayoutBox* layoutObject) {
+static IntRect clipBox(LayoutBox& layoutObject) {
   // TODO(chrishtr): pixel snapping is most likely incorrect here.
-  return pixelSnappedIntRect(layoutObject->clippingRect());
+  return pixelSnappedIntRect(layoutObject.clippingRect());
 }
 
 static LayoutPoint computeOffsetFromCompositedAncestor(
     const PaintLayer* layer,
     const PaintLayer* compositedAncestor) {
   LayoutPoint offset = layer->visualOffsetFromAncestor(compositedAncestor);
   if (compositedAncestor)
     offset.move(compositedAncestor->compositedLayerMapping()
                     ->owningLayer()
                     .subpixelAccumulation());
@@ skipping 116 matching lines @@
     IntSize newOffsetFromLayoutObject =
         -IntSize(offsetFromSquashLayerOrigin.width().round(),
                  offsetFromSquashLayerOrigin.height().round());
     LayoutSize subpixelAccumulation =
         offsetFromSquashLayerOrigin + newOffsetFromLayoutObject;
     if (layers[i].offsetFromLayoutObjectSet &&
         layers[i].offsetFromLayoutObject != newOffsetFromLayoutObject) {
       // It is ok to issue paint invalidation here, because all of the geometry
       // needed to correctly invalidate paint is computed by this point.
       DisablePaintInvalidationStateAsserts disabler;
-      ObjectPaintInvalidator(*layers[i].paintLayer->layoutObject())
+      ObjectPaintInvalidator(layers[i].paintLayer->layoutObject())
           .invalidatePaintIncludingNonCompositingDescendants();
 
       TRACE_LAYER_INVALIDATION(layers[i].paintLayer,
                                InspectorLayerInvalidationTrackingEvent::
                                    SquashingLayerGeometryWasUpdated);
       layersNeedingPaintInvalidation.push_back(layers[i].paintLayer);
     }
     layers[i].offsetFromLayoutObject = newOffsetFromLayoutObject;
     layers[i].offsetFromLayoutObjectSet = true;
 
@@ skipping 15 matching lines @@
 
 void CompositedLayerMapping::updateGraphicsLayerGeometry(
     const PaintLayer* compositingContainer,
     const PaintLayer* compositingStackingContext,
     Vector<PaintLayer*>& layersNeedingPaintInvalidation) {
   ASSERT(m_owningLayer.compositor()->lifecycle().state() ==
          DocumentLifecycle::InCompositingUpdate);
 
   // Set transform property, if it is not animating. We have to do this here
   // because the transform is affected by the layer dimensions.
-  if (!layoutObject()->style()->isRunningTransformAnimationOnCompositor())
-    updateTransform(layoutObject()->styleRef());
+  if (!layoutObject().style()->isRunningTransformAnimationOnCompositor())
+    updateTransform(layoutObject().styleRef());
 
   // Set opacity, if it is not animating.
-  if (!layoutObject()->style()->isRunningOpacityAnimationOnCompositor())
-    updateOpacity(layoutObject()->styleRef());
+  if (!layoutObject().style()->isRunningOpacityAnimationOnCompositor())
+    updateOpacity(layoutObject().styleRef());
 
-  if (!layoutObject()->style()->isRunningFilterAnimationOnCompositor())
-    updateFilters(layoutObject()->styleRef());
+  if (!layoutObject().style()->isRunningFilterAnimationOnCompositor())
+    updateFilters(layoutObject().styleRef());
 
-  if (!layoutObject()->style()->isRunningBackdropFilterAnimationOnCompositor())
-    updateBackdropFilters(layoutObject()->styleRef());
+  if (!layoutObject().style()->isRunningBackdropFilterAnimationOnCompositor())
+    updateBackdropFilters(layoutObject().styleRef());
 
   // We compute everything relative to the enclosing compositing layer.
   IntRect ancestorCompositingBounds;
   if (compositingContainer) {
     ASSERT(compositingContainer->hasCompositedLayerMapping());
     ancestorCompositingBounds = compositingContainer->compositedLayerMapping()
                                     ->pixelSnappedCompositedBounds();
   }
 
   IntRect localCompositingBounds;
@@ skipping 17 matching lines @@
   FloatSize contentsSize(relativeCompositingBounds.size());
 
   updateMainGraphicsLayerGeometry(relativeCompositingBounds,
                                   localCompositingBounds,
                                   graphicsLayerParentLocation);
   updateOverflowControlsHostLayerGeometry(compositingStackingContext,
                                           compositingContainer,
                                           graphicsLayerParentLocation);
   updateContentsOffsetInCompositingLayer(snappedOffsetFromCompositedAncestor,
                                          graphicsLayerParentLocation);
-  updateStickyConstraints(layoutObject()->styleRef());
+  updateStickyConstraints(layoutObject().styleRef());
   updateSquashingLayerGeometry(
       graphicsLayerParentLocation, compositingContainer, m_squashedLayers,
       m_squashingLayer.get(), &m_squashingLayerOffsetFromTransformedAncestor,
       layersNeedingPaintInvalidation);
 
   // If we have a layer that clips children, position it.
   IntRect clippingBox;
-  if (m_childContainmentLayer && layoutObject()->isBox())
+  if (m_childContainmentLayer && layoutObject().isBox())
     clippingBox = clipBox(toLayoutBox(layoutObject()));
 
   updateChildTransformLayerGeometry();
   updateChildContainmentLayerGeometry(clippingBox, localCompositingBounds);
 
   updateMaskLayerGeometry();
   updateTransformGeometry(snappedOffsetFromCompositedAncestor,
                           relativeCompositingBounds);
   updateForegroundLayerGeometry(contentsSize, clippingBox);
   updateBackgroundLayerGeometry(contentsSize);
   // TODO(yigu): Currently the decoration layer uses the same contentSize
   // as background layer and foreground layer. There are scenarios that
   // the sizes could be different. The actual size of the decoration layer
   // should be calculated separately.
   // The size of the background layer should be different as well. We need to
   // check whether we are painting the decoration layer into the background and
   // then ignore or consider the outline when determining the contentSize.
   updateDecorationOutlineLayerGeometry(contentsSize);
   updateScrollingLayerGeometry(localCompositingBounds);
   updateChildClippingMaskLayerGeometry();
 
   if (m_owningLayer.getScrollableArea() &&
       m_owningLayer.getScrollableArea()->scrollsOverflow())
     m_owningLayer.getScrollableArea()->positionOverflowControls();
 
-  updateLayerBlendMode(layoutObject()->styleRef());
+  updateLayerBlendMode(layoutObject().styleRef());
   updateIsRootForIsolatedGroup();
   updateContentsRect();
   updateBackgroundColor();
   updateDrawsContent();
   updateElementIdAndCompositorMutableProperties();
   updateBackgroundPaintsOntoScrollingContentsLayer();
   updateContentsOpaque();
   updateAfterPartResize();
   updateRenderingContext();
   updateShouldFlattenTransform();
@@ skipping 20 matching lines @@
 
   // m_graphicsLayer is the corresponding GraphicsLayer for this PaintLayer and
   // its non-compositing descendants. So, the visibility flag for
   // m_graphicsLayer should be true if there are any non-compositing visible
   // layers.
   bool contentsVisible = m_owningLayer.hasVisibleContent() ||
                          hasVisibleNonCompositingDescendant(&m_owningLayer);
   m_graphicsLayer->setContentsVisible(contentsVisible);
 
   m_graphicsLayer->setBackfaceVisibility(
-      layoutObject()->style()->backfaceVisibility() ==
+      layoutObject().style()->backfaceVisibility() ==
       BackfaceVisibilityVisible);
 }
 
 void CompositedLayerMapping::computeGraphicsLayerParentLocation(
     const PaintLayer* compositingContainer,
     const IntRect& ancestorCompositingBounds,
     IntPoint& graphicsLayerParentLocation) {
   if (compositingContainer &&
       compositingContainer->compositedLayerMapping()->hasClippingLayer() &&
-      compositingContainer->layoutObject()->isBox()) {
+      compositingContainer->layoutObject().isBox()) {
     // If the compositing ancestor has a layer to clip children, we parent in
     // that, and therefore position relative to it.
     IntRect clippingBox =
         clipBox(toLayoutBox(compositingContainer->layoutObject()));
     graphicsLayerParentLocation =
         clippingBox.location() +
         roundedIntSize(compositingContainer->subpixelAccumulation());
   } else if (compositingContainer &&
              compositingContainer->compositedLayerMapping()
                  ->childTransformLayer()) {
     // Similarly, if the compositing ancestor has a child transform layer, we
     // parent in that, and therefore position relative to it. It's already taken
     // into account the contents offset, so we do not need to here.
     graphicsLayerParentLocation =
         roundedIntPoint(compositingContainer->subpixelAccumulation());
   } else if (compositingContainer) {
     graphicsLayerParentLocation = ancestorCompositingBounds.location();
   } else {
     graphicsLayerParentLocation =
-        layoutObject()->view()->documentRect().location();
+        layoutObject().view()->documentRect().location();
   }
 
   if (compositingContainer &&
       compositingContainer->needsCompositedScrolling()) {
-    LayoutBox* layoutBox = toLayoutBox(compositingContainer->layoutObject());
-    IntSize scrollOffset = layoutBox->scrolledContentOffset();
+    LayoutBox& layoutBox = toLayoutBox(compositingContainer->layoutObject());
+    IntSize scrollOffset = layoutBox.scrolledContentOffset();
     IntPoint scrollOrigin =
         compositingContainer->getScrollableArea()->scrollOrigin();
-    scrollOrigin.move(-layoutBox->borderLeft().toInt(),
-                      -layoutBox->borderTop().toInt());
+    scrollOrigin.move(-layoutBox.borderLeft().toInt(),
+                      -layoutBox.borderTop().toInt());
     graphicsLayerParentLocation = -(scrollOrigin + scrollOffset);
   }
 }
 
 void CompositedLayerMapping::updateAncestorClippingLayerGeometry(
     const PaintLayer* compositingContainer,
     const IntPoint& snappedOffsetFromCompositedAncestor,
     IntPoint& graphicsLayerParentLocation) {
   if (!compositingContainer || !m_ancestorClippingLayer)
     return;
@@ skipping 74 matching lines @@
       }
 
       m_overflowControlsAncestorClippingLayer->setPosition(position);
       hostLayerPosition.move(
           -m_ancestorClippingLayer->offsetFromLayoutObject());
     } else {
       // The controls are in the same 2D space as the compositing container, so
       // we can map them into the space of the container.
       TransformState transformState(TransformState::ApplyTransformDirection,
                                     FloatPoint());
-      m_owningLayer.layoutObject()->mapLocalToAncestor(
-          compositingStackingContext->layoutObject(), transformState,
+      m_owningLayer.layoutObject().mapLocalToAncestor(
+          &compositingStackingContext->layoutObject(), transformState,
           ApplyContainerFlip);
       transformState.flatten();
       hostLayerPosition = LayoutPoint(transformState.lastPlanarPoint());
       if (PaintLayerScrollableArea* scrollableArea =
               compositingStackingContext->getScrollableArea()) {
         hostLayerPosition.move(
             LayoutSize(toFloatSize(scrollableArea->scrollPosition())));
       }
       hostLayerPosition.move(-stackingOffsetFromLayoutObject);
     }
   } else {
     hostLayerPosition.move(-m_graphicsLayer->offsetFromLayoutObject());
   }
 
   m_overflowControlsHostLayer->setPosition(FloatPoint(hostLayerPosition));
 
   const IntRect borderBox =
-      toLayoutBox(m_owningLayer.layoutObject())->pixelSnappedBorderBoxRect();
+      toLayoutBox(m_owningLayer.layoutObject()).pixelSnappedBorderBoxRect();
   m_overflowControlsHostLayer->setSize(FloatSize(borderBox.size()));
   m_overflowControlsHostLayer->setMasksToBounds(true);
 }
 
 void CompositedLayerMapping::updateChildContainmentLayerGeometry(
     const IntRect& clippingBox,
     const IntRect& localCompositingBounds) {
   if (!m_childContainmentLayer)
     return;
 
   FloatPoint clipPositionInLayoutObjectSpace(
       clippingBox.location() - localCompositingBounds.location() +
       roundedIntSize(m_owningLayer.subpixelAccumulation()));
 
   // If there are layers between the the child containment layer and
   // m_graphicsLayer (eg, the child transform layer), we must adjust the clip
   // position to get it in the correct space.
   FloatPoint clipPositionInParentSpace = clipPositionInLayoutObjectSpace;
   for (GraphicsLayer* ancestor = m_childContainmentLayer->parent();
        ancestor != mainGraphicsLayer(); ancestor = ancestor->parent())
     clipPositionInParentSpace -= toFloatSize(ancestor->position());
 
   m_childContainmentLayer->setPosition(clipPositionInParentSpace);
   m_childContainmentLayer->setSize(FloatSize(clippingBox.size()));
   m_childContainmentLayer->setOffsetFromLayoutObject(
       toIntSize(clippingBox.location()));
   if (m_childClippingMaskLayer && !m_scrollingLayer &&
-      !layoutObject()->style()->clipPath()) {
+      !layoutObject().style()->clipPath()) {
     m_childClippingMaskLayer->setSize(m_childContainmentLayer->size());
     m_childClippingMaskLayer->setOffsetFromLayoutObject(
         m_childContainmentLayer->offsetFromLayoutObject());
   }
 }
 
 void CompositedLayerMapping::updateChildTransformLayerGeometry() {
   if (!m_childTransformLayer)
     return;
   const IntRect borderBox =
-      toLayoutBox(m_owningLayer.layoutObject())->pixelSnappedBorderBoxRect();
+      toLayoutBox(m_owningLayer.layoutObject()).pixelSnappedBorderBoxRect();
   m_childTransformLayer->setSize(FloatSize(borderBox.size()));
   m_childTransformLayer->setPosition(
       FloatPoint(contentOffsetInCompositingLayer()));
 }
 
 void CompositedLayerMapping::updateMaskLayerGeometry() {
   if (!m_maskLayer)
     return;
 
   if (m_maskLayer->size() != m_graphicsLayer->size()) {
     m_maskLayer->setSize(m_graphicsLayer->size());
     m_maskLayer->setNeedsDisplay();
   }
   m_maskLayer->setPosition(FloatPoint());
   m_maskLayer->setOffsetFromLayoutObject(
       m_graphicsLayer->offsetFromLayoutObject());
 }
 
 void CompositedLayerMapping::updateTransformGeometry(
     const IntPoint& snappedOffsetFromCompositedAncestor,
     const IntRect& relativeCompositingBounds) {
   if (m_owningLayer.hasTransformRelatedProperty()) {
-    const LayoutRect borderBox = toLayoutBox(layoutObject())->borderBoxRect();
+    const LayoutRect borderBox = toLayoutBox(layoutObject()).borderBoxRect();
 
     // Get layout bounds in the coords of compositingContainer to match
     // relativeCompositingBounds.
     IntRect layerBounds = pixelSnappedIntRect(
         toLayoutPoint(m_owningLayer.subpixelAccumulation()), borderBox.size());
     layerBounds.moveBy(snappedOffsetFromCompositedAncestor);
 
     // Update properties that depend on layer dimensions
     FloatPoint3D transformOrigin =
         computeTransformOrigin(IntRect(IntPoint(), layerBounds.size()));
@@ skipping 14 matching lines @@
     m_graphicsLayer->setTransformOrigin(compositedTransformOrigin);
   }
 }
 
 void CompositedLayerMapping::updateScrollingLayerGeometry(
     const IntRect& localCompositingBounds) {
   if (!m_scrollingLayer)
     return;
 
   ASSERT(m_scrollingContentsLayer);
-  LayoutBox* layoutBox = toLayoutBox(layoutObject());
+  LayoutBox& layoutBox = toLayoutBox(layoutObject());
   IntRect overflowClipRect =
-      pixelSnappedIntRect(layoutBox->overflowClipRect(LayoutPoint()));
+      pixelSnappedIntRect(layoutBox.overflowClipRect(LayoutPoint()));
 
   const TopDocumentRootScrollerController& globalRootScrollerController =
-      layoutBox->document().frameHost()->globalRootScrollerController();
+      layoutBox.document().frameHost()->globalRootScrollerController();
 
   if (&m_owningLayer == globalRootScrollerController.rootScrollerPaintLayer()) {
     LayoutRect clipRect =
-        layoutBox->document().layoutView()->overflowClipRect(LayoutPoint());
+        layoutBox.document().layoutView()->overflowClipRect(LayoutPoint());
     DCHECK(clipRect.size() == LayoutSize(pixelSnappedIntRect(clipRect).size()));
     overflowClipRect.setSize(pixelSnappedIntRect(clipRect).size());
   }
 
   // When a m_childTransformLayer exists, local content offsets for the
   // m_scrollingLayer have already been applied. Otherwise, we apply them here.
   IntSize localContentOffset(0, 0);
   if (!m_childTransformLayer) {
     localContentOffset = roundedIntPoint(m_owningLayer.subpixelAccumulation()) -
                          localCompositingBounds.location();
   }
   m_scrollingLayer->setPosition(
       FloatPoint(overflowClipRect.location() + localContentOffset));
   m_scrollingLayer->setSize(FloatSize(overflowClipRect.size()));
 
   IntSize oldScrollingLayerOffset = m_scrollingLayer->offsetFromLayoutObject();
   m_scrollingLayer->setOffsetFromLayoutObject(
       -toIntSize(overflowClipRect.location()));
 
-  if (m_childClippingMaskLayer && !layoutObject()->style()->clipPath()) {
+  if (m_childClippingMaskLayer && !layoutObject().style()->clipPath()) {
     m_childClippingMaskLayer->setPosition(m_scrollingLayer->position());
     m_childClippingMaskLayer->setSize(m_scrollingLayer->size());
     m_childClippingMaskLayer->setOffsetFromLayoutObject(
         toIntSize(overflowClipRect.location()));
   }
 
   bool overflowClipRectOffsetChanged =
       oldScrollingLayerOffset != m_scrollingLayer->offsetFromLayoutObject();
 
-  IntSize scrollSize(layoutBox->pixelSnappedScrollWidth(),
-                     layoutBox->pixelSnappedScrollHeight());
+  IntSize scrollSize(layoutBox.pixelSnappedScrollWidth(),
+                     layoutBox.pixelSnappedScrollHeight());
   if (overflowClipRectOffsetChanged)
     m_scrollingContentsLayer->setNeedsDisplay();
 
   FloatPoint scrollPosition =
       m_owningLayer.getScrollableArea()->scrollPosition();
   DoubleSize scrollingContentsOffset(
       overflowClipRect.location().x() - scrollPosition.x(),
       overflowClipRect.location().y() - scrollPosition.y());
   // The scroll offset change is compared using floating point so that
   // fractional scroll offset change can be propagated to compositor.
@@ skipping 25 matching lines @@
   if (m_foregroundLayer) {
     if (m_foregroundLayer->size() != m_scrollingContentsLayer->size())
       m_foregroundLayer->setSize(m_scrollingContentsLayer->size());
     m_foregroundLayer->setNeedsDisplay();
     m_foregroundLayer->setOffsetFromLayoutObject(
         m_scrollingContentsLayer->offsetFromLayoutObject());
   }
 }
 
 void CompositedLayerMapping::updateChildClippingMaskLayerGeometry() {
-  if (!m_childClippingMaskLayer || !layoutObject()->style()->clipPath() ||
-      !layoutObject()->isBox())
+  if (!m_childClippingMaskLayer || !layoutObject().style()->clipPath() ||
+      !layoutObject().isBox())
     return;
-  LayoutBox* layoutBox = toLayoutBox(layoutObject());
-  IntRect clientBox = enclosingIntRect(layoutBox->clientBoxRect());
+  LayoutBox& layoutBox = toLayoutBox(layoutObject());
+  IntRect clientBox = enclosingIntRect(layoutBox.clientBoxRect());
 
   m_childClippingMaskLayer->setPosition(m_graphicsLayer->position());
   m_childClippingMaskLayer->setSize(m_graphicsLayer->size());
   m_childClippingMaskLayer->setOffsetFromLayoutObject(
       toIntSize(clientBox.location()));
 
   // NOTE: also some stuff happening in updateChildContainmentLayerGeometry().
 }
 
 void CompositedLayerMapping::updateForegroundLayerGeometry(
@@ skipping 33 matching lines @@
   // updateScrollingLayerGeometry().
 }
 
 void CompositedLayerMapping::updateBackgroundLayerGeometry(
     const FloatSize& relativeCompositingBoundsSize) {
   if (!m_backgroundLayer)
     return;
 
   FloatSize backgroundSize = relativeCompositingBoundsSize;
   if (backgroundLayerPaintsFixedRootBackground()) {
-    FrameView* frameView = toLayoutView(layoutObject())->frameView();
+    FrameView* frameView = toLayoutView(layoutObject()).frameView();
     backgroundSize = FloatSize(frameView->visibleContentRect().size());
   }
   m_backgroundLayer->setPosition(FloatPoint());
   if (backgroundSize != m_backgroundLayer->size()) {
     m_backgroundLayer->setSize(backgroundSize);
     m_backgroundLayer->setNeedsDisplay();
   }
   m_backgroundLayer->setOffsetFromLayoutObject(
       m_graphicsLayer->offsetFromLayoutObject());
 }
@@ skipping 19 matching lines @@
       scrollingCoordinatorFromLayer(m_owningLayer);
   if (!scrollingCoordinator)
     return;
 
   scrollingCoordinator->updateLayerPositionConstraint(&m_owningLayer);
 
   // Page scale is applied as a transform on the root layout view layer. Because
   // the scroll layer is further up in the hierarchy, we need to avoid marking
   // the root layout view layer as a container.
   bool isContainer =
-      m_owningLayer.layoutObject()->style()->canContainFixedPositionObjects() &&
+      m_owningLayer.layoutObject().style()->canContainFixedPositionObjects() &&
       !m_owningLayer.isRootLayer();
   scrollingCoordinator->setLayerIsContainerForFixedPositionLayers(
       m_graphicsLayer.get(), isContainer);
 }
 
 void CompositedLayerMapping::updateInternalHierarchy() {
   // m_foregroundLayer has to be inserted in the correct order with child
   // layers, so it's not inserted here.
   if (m_ancestorClippingLayer)
     m_ancestorClippingLayer->removeAllChildren();
@@ skipping 16 matching lines @@
   updateBottomLayer(m_childContainmentLayer.get());
   updateBottomLayer(m_scrollingLayer.get());
 
   // Now constructing the subtree for the overflow controls.
   bottomLayer = m_graphicsLayer.get();
   // TODO(pdr): Ensure painting uses the correct GraphicsLayer when root layer
   // scrolls is enabled.  crbug.com/638719
   if (m_isMainFrameLayoutViewLayer &&
       !RuntimeEnabledFeatures::slimmingPaintV2Enabled())
     bottomLayer = layoutObject()
-                      ->frame()
+                      .frame()
                       ->page()
                       ->frameHost()
                       .visualViewport()
                       .containerLayer();
   updateBottomLayer(m_overflowControlsAncestorClippingLayer.get());
   updateBottomLayer(m_overflowControlsHostLayer.get());
   if (m_layerForHorizontalScrollbar)
     m_overflowControlsHostLayer->addChild(m_layerForHorizontalScrollbar.get());
   if (m_layerForVerticalScrollbar)
     m_overflowControlsHostLayer->addChild(m_layerForVerticalScrollbar.get());
@@ skipping 88 matching lines @@
   // graphicsLayerParentLocation it appears).
   FloatPoint offsetDueToAncestorGraphicsLayers =
       m_graphicsLayer->position() + graphicsLayerParentLocation;
   m_contentOffsetInCompositingLayer = LayoutSize(
       snappedOffsetFromCompositedAncestor - offsetDueToAncestorGraphicsLayers);
   m_contentOffsetInCompositingLayerDirty = false;
 }
 
 void CompositedLayerMapping::updateDrawsContent() {
   bool inOverlayFullscreenVideo = false;
-  if (layoutObject()->isVideo()) {
-    HTMLVideoElement* videoElement = toHTMLVideoElement(layoutObject()->node());
+  if (layoutObject().isVideo()) {
+    HTMLVideoElement* videoElement = toHTMLVideoElement(layoutObject().node());
     if (videoElement->isFullscreen() &&
         videoElement->usesOverlayFullscreenVideo())
       inOverlayFullscreenVideo = true;
   }
   bool hasPaintedContent =
       inOverlayFullscreenVideo ? false : containsPaintedContent();
   m_graphicsLayer->setDrawsContent(hasPaintedContent);
 
   if (m_scrollingLayer) {
     // m_scrollingLayer never has backing store.
     // m_scrollingContentsLayer only needs backing store if the scrolled
     // contents need to paint.
     m_scrollingContentsAreEmpty =
         !m_owningLayer.hasVisibleContent() ||
-        !(layoutObject()->styleRef().hasBackground() ||
-          layoutObject()->hasBackdropFilter() || paintsChildren());
+        !(layoutObject().styleRef().hasBackground() ||
+          layoutObject().hasBackdropFilter() || paintsChildren());
     m_scrollingContentsLayer->setDrawsContent(!m_scrollingContentsAreEmpty);
   }
 
   m_drawsBackgroundOntoContentLayer = false;
 
   if (hasPaintedContent && isAcceleratedCanvas(layoutObject())) {
     CanvasRenderingContext* context =
-        toHTMLCanvasElement(layoutObject()->node())->renderingContext();
+        toHTMLCanvasElement(layoutObject().node())->renderingContext();
     // Content layer may be null if context is lost.
     if (WebLayer* contentLayer = context->platformLayer()) {
       Color bgColor(Color::transparent);
       if (contentLayerSupportsDirectBackgroundComposition(layoutObject())) {
         bgColor = layoutObjectBackgroundColor();
         hasPaintedContent = false;
         m_drawsBackgroundOntoContentLayer = true;
       }
       contentLayer->setBackgroundColor(bgColor.rgb());
     }
@@ skipping 344 matching lines @@
   // NB, it is illegal at this point to query an ancestor's compositing state.
   // Some compositing reasons depend on the compositing state of ancestors. So
   // if we want a rendering context id for the context root, we cannot ask for
   // the id of its associated WebLayer now; it may not have one yet. We could do
   // a second pass after doing the compositing updates to get these ids, but
   // this would actually be harmful. We do not want to attach any semantic
   // meaning to the context id other than the fact that they group a number of
   // layers together for the sake of 3d sorting. So instead we will ask the
   // compositor to vend us an arbitrary, but consistent id.
   if (PaintLayer* root = m_owningLayer.renderingContextRoot()) {
-    if (Node* node = root->layoutObject()->node())
+    if (Node* node = root->layoutObject().node())
       id = static_cast<int>(PtrHash<Node>::hash(node));
   }
 
   UpdateRenderingContextFunctor functor = {id};
   ApplyToGraphicsLayers<UpdateRenderingContextFunctor>(
       this, functor, ApplyToAllGraphicsLayers);
 }
 
 struct UpdateShouldFlattenTransformFunctor {
   void operator()(GraphicsLayer* layer) const {
@@ skipping 41 matching lines @@
 //
 // The element id for the scroll layers is assigned when they're constructed,
 // since this is unconditional. However, the element id for the primary layer as
 // well as the mutable properties for all layers may change according to the
 // rules above so we update those values here.
 void CompositedLayerMapping::updateElementIdAndCompositorMutableProperties() {
   int elementId = 0;
   uint32_t primaryMutableProperties = CompositorMutableProperty::kNone;
   uint32_t scrollMutableProperties = CompositorMutableProperty::kNone;
 
-  Node* owningNode = m_owningLayer.layoutObject()->node();
+  Node* owningNode = m_owningLayer.layoutObject().node();
   Element* animatingElement = nullptr;
   const ComputedStyle* animatingStyle = nullptr;
   if (owningNode) {
     Document& document = owningNode->document();
     Element* scrollingElement = document.scrollingElementNoLayout();
     if (owningNode->isElementNode() &&
         (!RuntimeEnabledFeatures::rootLayerScrollingEnabled() ||
          owningNode != scrollingElement)) {
       animatingElement = toElement(owningNode);
-      animatingStyle = m_owningLayer.layoutObject()->style();
+      animatingStyle = m_owningLayer.layoutObject().style();
     } else if (owningNode->isDocumentNode() &&
                RuntimeEnabledFeatures::rootLayerScrollingEnabled()) {
       owningNode = animatingElement = scrollingElement;
       if (scrollingElement && scrollingElement->layoutObject())
         animatingStyle = scrollingElement->layoutObject()->style();
     }
   }
 
   if (RuntimeEnabledFeatures::compositorWorkerEnabled() && animatingStyle &&
       animatingStyle->hasCompositorProxy()) {
@@ skipping 55 matching lines @@
       layerChanged = true;
     }
   } else {
     if (m_backgroundLayer) {
       m_backgroundLayer->removeFromParent();
       m_backgroundLayer = nullptr;
       layerChanged = true;
     }
   }
 
-  if (layerChanged && !m_owningLayer.layoutObject()->documentBeingDestroyed())
+  if (layerChanged && !m_owningLayer.layoutObject().documentBeingDestroyed())
     compositor()->rootFixedBackgroundsChanged();
 
   return layerChanged;
 }
 
 bool CompositedLayerMapping::updateDecorationOutlineLayer(
     bool needsDecorationOutlineLayer) {
   bool layerChanged = false;
   if (needsDecorationOutlineLayer) {
     if (!m_decorationOutlineLayer) {
@@ skipping 49 matching lines @@
     if (!m_scrollingLayer) {
       // Outer layer which corresponds with the scroll view.
       m_scrollingLayer =
           createGraphicsLayer(CompositingReasonLayerForScrollingContainer);
       m_scrollingLayer->setDrawsContent(false);
 
       // Inner layer which renders the content that scrolls.
       m_scrollingContentsLayer =
           createGraphicsLayer(CompositingReasonLayerForScrollingContents);
 
-      if (Node* owningNode = m_owningLayer.layoutObject()->node())
+      if (Node* owningNode = m_owningLayer.layoutObject().node())
         m_scrollingContentsLayer->setElementId(createCompositorElementId(
             DOMNodeIds::idForNode(owningNode), CompositorSubElementId::Scroll));
 
       m_scrollingLayer->addChild(m_scrollingContentsLayer.get());
 
       layerChanged = true;
       if (scrollingCoordinator) {
         scrollingCoordinator->scrollableAreaScrollLayerDidChange(
             m_owningLayer.getScrollableArea());
         scrollingCoordinator->scrollableAreasDidChange();
@@ skipping 172 matching lines @@
     // break here.
     //
     // FIXME: with grouped backings, a composited descendant will have to
     // continue past the grouped (squashed) layers that its parents may
     // contribute to. This whole confusion can be avoided by specifying
     // explicitly the composited ancestor where we would stop accumulating
     // opacity.
     if (curr->compositingState() == PaintsIntoOwnBacking)
       break;
 
-    finalOpacity *= curr->layoutObject()->opacity();
+    finalOpacity *= curr->layoutObject().opacity();
   }
 
   return finalOpacity;
 }
 
 Color CompositedLayerMapping::layoutObjectBackgroundColor() const {
-  return layoutObject()->resolveColor(CSSPropertyBackgroundColor);
+  return layoutObject().resolveColor(CSSPropertyBackgroundColor);
 }
 
 void CompositedLayerMapping::updateBackgroundColor() {
   m_graphicsLayer->setBackgroundColor(layoutObjectBackgroundColor());
 }
 
 bool CompositedLayerMapping::paintsChildren() const {
   if (m_owningLayer.hasVisibleContent() &&
       m_owningLayer.hasNonEmptyChildLayoutObjects())
     return true;
 
   if (hasVisibleNonCompositingDescendant(&m_owningLayer))
     return true;
 
   return false;
 }
 
-static bool isCompositedPlugin(LayoutObject* layoutObject) {
-  return layoutObject->isEmbeddedObject() &&
-         toLayoutEmbeddedObject(layoutObject)->requiresAcceleratedCompositing();
+static bool isCompositedPlugin(LayoutObject& layoutObject) {
+  return layoutObject.isEmbeddedObject() &&
+         toLayoutEmbeddedObject(layoutObject).requiresAcceleratedCompositing();
 }
 
 bool CompositedLayerMapping::hasVisibleNonCompositingDescendant(
     PaintLayer* parent) {
   if (!parent->hasVisibleDescendant())
     return false;
 
   // FIXME: We shouldn't be called with a stale z-order lists. See bug 85512.
   parent->stackingNode()->updateLayerListsIfNeeded();
 
 #if DCHECK_IS_ON()
   LayerListMutationDetector mutationChecker(parent->stackingNode());
 #endif
 
   PaintLayerStackingNodeIterator normalFlowIterator(*parent->stackingNode(),
                                                     AllChildren);
   while (PaintLayerStackingNode* curNode = normalFlowIterator.next()) {
     PaintLayer* curLayer = curNode->layer();
     if (curLayer->hasCompositedLayerMapping())
       continue;
     if (curLayer->hasVisibleContent() ||
         hasVisibleNonCompositingDescendant(curLayer))
       return true;
   }
 
   return false;
 }
 
 bool CompositedLayerMapping::containsPaintedContent() const {
-  if (layoutObject()->isImage() && isDirectlyCompositedImage())
+  if (layoutObject().isImage() && isDirectlyCompositedImage())
     return false;
 
-  LayoutObject* layoutObject = this->layoutObject();
+  LayoutObject& layoutObject = this->layoutObject();
   // FIXME: we could optimize cases where the image, video or canvas is known to
   // fill the border box entirely, and set background color on the layer in that
   // case, instead of allocating backing store and painting.
-  if (layoutObject->isVideo() &&
-      toLayoutVideo(layoutObject)->shouldDisplayVideo())
+  if (layoutObject.isVideo() &&
+      toLayoutVideo(layoutObject).shouldDisplayVideo())
     return m_owningLayer.hasBoxDecorationsOrBackground();
 
   if (m_owningLayer.hasVisibleBoxDecorations())
     return true;
 
-  if (layoutObject->hasMask())  // masks require special treatment
+  if (layoutObject.hasMask())  // masks require special treatment
     return true;
 
-  if (layoutObject->isAtomicInlineLevel() && !isCompositedPlugin(layoutObject))
+  if (layoutObject.isAtomicInlineLevel() && !isCompositedPlugin(layoutObject))
     return true;
 
-  if (layoutObject->isLayoutMultiColumnSet())
+  if (layoutObject.isLayoutMultiColumnSet())
     return true;
 
-  if (layoutObject->node() && layoutObject->node()->isDocumentNode()) {
+  if (layoutObject.node() && layoutObject.node()->isDocumentNode()) {
     // Look to see if the root object has a non-simple background
     LayoutObject* rootObject =
-        layoutObject->document().documentElement()
-            ? layoutObject->document().documentElement()->layoutObject()
+        layoutObject.document().documentElement()
+            ? layoutObject.document().documentElement()->layoutObject()
             : 0;
     // Reject anything that has a border, a border-radius or outline,
     // or is not a simple background (no background, or solid color).
     if (rootObject &&
         hasBoxDecorationsOrBackgroundImage(rootObject->styleRef()))
       return true;
 
     // Now look at the body's layoutObject.
-    HTMLElement* body = layoutObject->document().body();
+    HTMLElement* body = layoutObject.document().body();
     LayoutObject* bodyObject =
         isHTMLBodyElement(body) ? body->layoutObject() : 0;
     if (bodyObject &&
         hasBoxDecorationsOrBackgroundImage(bodyObject->styleRef()))
       return true;
   }
 
   // FIXME: it's O(n^2). A better solution is needed.
   return paintsChildren();
 }
 
 // An image can be directly composited if it's the sole content of the layer,
 // and has no box decorations or clipping that require painting. Direct
 // compositing saves a backing store.
 bool CompositedLayerMapping::isDirectlyCompositedImage() const {
-  ASSERT(layoutObject()->isImage());
-  LayoutImage* imageLayoutObject = toLayoutImage(layoutObject());
+  DCHECK(layoutObject().isImage());
+  LayoutImage& imageLayoutObject = toLayoutImage(layoutObject());
 
   if (m_owningLayer.hasBoxDecorationsOrBackground() ||
-      imageLayoutObject->hasClip() || imageLayoutObject->hasClipPath() ||
-      imageLayoutObject->hasObjectFit())
+      imageLayoutObject.hasClip() || imageLayoutObject.hasClipPath() ||
+      imageLayoutObject.hasObjectFit())
     return false;
 
-  if (ImageResourceContent* cachedImage = imageLayoutObject->cachedImage()) {
+  if (ImageResourceContent* cachedImage = imageLayoutObject.cachedImage()) {
     if (!cachedImage->hasImage())
       return false;
 
     Image* image = cachedImage->getImage();
     if (!image->isBitmapImage())
       return false;
 
     return true;
   }
 
   return false;
 }
 
 void CompositedLayerMapping::contentChanged(ContentChangeType changeType) {
-  if ((changeType == ImageChanged) && layoutObject()->isImage() &&
+  if ((changeType == ImageChanged) && layoutObject().isImage() &&
       isDirectlyCompositedImage()) {
     updateImageContents();
     return;
   }
 
   if (changeType == CanvasChanged && isAcceleratedCanvas(layoutObject())) {
     m_graphicsLayer->setContentsNeedsDisplay();
     return;
   }
 }
 
 void CompositedLayerMapping::updateImageContents() {
-  ASSERT(layoutObject()->isImage());
-  LayoutImage* imageLayoutObject = toLayoutImage(layoutObject());
+  DCHECK(layoutObject().isImage());
+  LayoutImage& imageLayoutObject = toLayoutImage(layoutObject());
 
-  ImageResourceContent* cachedImage = imageLayoutObject->cachedImage();
+  ImageResourceContent* cachedImage = imageLayoutObject.cachedImage();
   if (!cachedImage)
     return;
 
   Image* image = cachedImage->getImage();
   if (!image)
     return;
 
   // This is a no-op if the layer doesn't have an inner layer for the image.
   m_graphicsLayer->setContentsToImage(
-      image, LayoutObject::shouldRespectImageOrientation(imageLayoutObject));
+      image, LayoutObject::shouldRespectImageOrientation(&imageLayoutObject));
 
-  m_graphicsLayer->setFilterQuality(layoutObject()->style()->imageRendering() ==
+  m_graphicsLayer->setFilterQuality(layoutObject().style()->imageRendering() ==
                                             ImageRenderingPixelated
                                         ? kNone_SkFilterQuality
                                         : kLow_SkFilterQuality);
 
   // Prevent double-drawing: https://bugs.webkit.org/show_bug.cgi?id=58632
   updateDrawsContent();
 
   // Image animation is "lazy", in that it automatically stops unless someone is
   // drawing the image. So we have to kick the animation each time; this has the
   // downside that the image will keep animating, even if its layer is not
   // visible.
   image->startAnimation();
 }
 
 FloatPoint3D CompositedLayerMapping::computeTransformOrigin(
     const IntRect& borderBox) const {
-  const ComputedStyle& style = layoutObject()->styleRef();
+  const ComputedStyle& style = layoutObject().styleRef();
 
   FloatPoint3D origin;
   origin.setX(floatValueForLength(style.transformOriginX(), borderBox.width()));
   origin.setY(
       floatValueForLength(style.transformOriginY(), borderBox.height()));
   origin.setZ(style.transformOriginZ());
 
   return origin;
 }
 
@@ skipping 113 matching lines @@
 
   IntRect r;
   PaintInvalidationReason invalidationReason;
   const DisplayItemClient& client;
 };
 
 void CompositedLayerMapping::setContentsNeedDisplayInRect(
     const LayoutRect& r,
     PaintInvalidationReason invalidationReason,
     const DisplayItemClient& client) {
-  DCHECK(!m_owningLayer.layoutObject()->usesCompositedScrolling());
+  DCHECK(!m_owningLayer.layoutObject().usesCompositedScrolling());
   // TODO(wangxianzhu): Enable the following assert after paint invalidation for
   // spv2 is ready.
   // ASSERT(!RuntimeEnabledFeatures::slimmingPaintV2Enabled());
 
   SetContentsNeedsDisplayInRectFunctor functor = {
       enclosingIntRect(LayoutRect(
           r.location() + m_owningLayer.subpixelAccumulation(), r.size())),
       invalidationReason, client};
   ApplyToGraphicsLayers(this, functor, ApplyToContentLayers);
 }
 
 void CompositedLayerMapping::setNonScrollingContentsNeedDisplayInRect(
     const LayoutRect& r,
     PaintInvalidationReason invalidationReason,
     const DisplayItemClient& client) {
-  DCHECK(m_owningLayer.layoutObject()->usesCompositedScrolling());
+  DCHECK(m_owningLayer.layoutObject().usesCompositedScrolling());
   // TODO(wangxianzhu): Enable the following assert after paint invalidation for
   // spv2 is ready.
   // ASSERT(!RuntimeEnabledFeatures::slimmingPaintV2Enabled());
 
   SetContentsNeedsDisplayInRectFunctor functor = {
       enclosingIntRect(LayoutRect(
           r.location() + m_owningLayer.subpixelAccumulation(), r.size())),
       invalidationReason, client};
   ApplyToGraphicsLayers(this, functor, ApplyToNonScrollingContentLayers);
 }
 
 void CompositedLayerMapping::setScrollingContentsNeedDisplayInRect(
     const LayoutRect& r,
     PaintInvalidationReason invalidationReason,
     const DisplayItemClient& client) {
-  DCHECK(m_owningLayer.layoutObject()->usesCompositedScrolling());
+  DCHECK(m_owningLayer.layoutObject().usesCompositedScrolling());
   // TODO(wangxianzhu): Enable the following assert after paint invalidation for
   // spv2 is ready.
   // ASSERT(!RuntimeEnabledFeatures::slimmingPaintV2Enabled());
 
   SetContentsNeedsDisplayInRectFunctor functor = {
       enclosingIntRect(LayoutRect(
           r.location() + m_owningLayer.subpixelAccumulation(), r.size())),
       invalidationReason, client};
   ApplyToGraphicsLayers(this, functor, ApplyToScrollingContentLayers);
 }
 
 const GraphicsLayerPaintInfo* CompositedLayerMapping::containingSquashedLayer(
     const LayoutObject* layoutObject,
     const Vector<GraphicsLayerPaintInfo>& layers,
     unsigned maxSquashedLayerIndex) {
   if (!layoutObject)
     return nullptr;
   for (size_t i = 0; i < layers.size() && i < maxSquashedLayerIndex; ++i) {
-    if (layoutObject->isDescendantOf(layers[i].paintLayer->layoutObject()))
+    if (layoutObject->isDescendantOf(&layers[i].paintLayer->layoutObject()))
       return &layers[i];
   }
   return nullptr;
 }
 
 const GraphicsLayerPaintInfo* CompositedLayerMapping::containingSquashedLayer(
     const LayoutObject* layoutObject,
     unsigned maxSquashedLayerIndex) {
   return CompositedLayerMapping::containingSquashedLayer(
       layoutObject, m_squashedLayers, maxSquashedLayerIndex);
@@ skipping 55 matching lines @@
                          PaintLayerPaintingAncestorClippingMaskPhase)) {
     dirtyRect.move(
         roundedIntSize(paintInfo.paintLayer->subpixelAccumulation()));
   } else {
     LayoutRect bounds = paintInfo.compositedBounds;
     bounds.move(paintInfo.paintLayer->subpixelAccumulation());
     dirtyRect.intersect(pixelSnappedIntRect(bounds));
   }
 
 #if DCHECK_IS_ON()
-  if (!layoutObject()->view()->frame() ||
-      !layoutObject()->view()->frame()->shouldThrottleRendering())
-    paintInfo.paintLayer->layoutObject()->assertSubtreeIsLaidOut();
+  if (!layoutObject().view()->frame() ||
+      !layoutObject().view()->frame()->shouldThrottleRendering())
+    paintInfo.paintLayer->layoutObject().assertSubtreeIsLaidOut();
 #endif
 
   float deviceScaleFactor =
-      blink::deviceScaleFactor(paintInfo.paintLayer->layoutObject()->frame());
+      blink::deviceScaleFactor(paintInfo.paintLayer->layoutObject().frame());
   context.setDeviceScaleFactor(deviceScaleFactor);
 
   if (paintInfo.paintLayer->compositingState() != PaintsIntoGroupedBacking) {
     // FIXME: GraphicsLayers need a way to split for multicol.
     PaintLayerPaintingInfo paintingInfo(
         paintInfo.paintLayer, LayoutRect(dirtyRect), GlobalPaintNormalPhase,
         paintInfo.paintLayer->subpixelAccumulation());
     PaintLayerPainter(*paintInfo.paintLayer)
         .paintLayerContents(context, paintingInfo, paintLayerFlags);
 
@@ skipping 59 matching lines @@
   if (graphicsLayer == m_squashingLayer.get()) {
     // TODO(chrishtr): this is a speculative fix for crbug.com/561306. However,
     // it should never be the case that m_squashingLayer exists,
     // yet m_squashedLayers.size() == 0. There must be a bug elsewhere.
     if (m_squashedLayers.size() == 0)
       return IntRect();
     // All squashed layers have the same clip and transform space, so we can use
     // the first squashed layer's layoutObject to map the squashing layer's
     // bounds into viewport space, with offsetFromAnchorLayoutObject to
     // translate squashing layer's bounds into the first squashed layer's space.
-    anchorLayoutObject = m_squashedLayers[0].paintLayer->layoutObject();
+    anchorLayoutObject = &m_squashedLayers[0].paintLayer->layoutObject();
     offsetFromAnchorLayoutObject = m_squashedLayers[0].offsetFromLayoutObject;
   } else {
     ASSERT(graphicsLayer == m_graphicsLayer.get() ||
            graphicsLayer == m_scrollingContentsLayer.get());
-    anchorLayoutObject = m_owningLayer.layoutObject();
+    anchorLayoutObject = &m_owningLayer.layoutObject();
     offsetFromAnchorLayoutObject = graphicsLayer->offsetFromLayoutObject();
     adjustForCompositedScrolling(graphicsLayer, offsetFromAnchorLayoutObject);
   }
 
   // Start with the bounds of the graphics layer in the space of the anchor
   // LayoutObject.
   FloatRect graphicsLayerBoundsInObjectSpace(graphicsLayerBounds);
   graphicsLayerBoundsInObjectSpace.move(offsetFromAnchorLayoutObject);
 
   // Now map the bounds to its visible content rect in root view space,
@@ skipping 134 matching lines @@
 void CompositedLayerMapping::paintContents(
     const GraphicsLayer* graphicsLayer,
     GraphicsContext& context,
     GraphicsLayerPaintingPhase graphicsLayerPaintingPhase,
     const IntRect& interestRect) const {
   // https://code.google.com/p/chromium/issues/detail?id=343772
   DisableCompositingQueryAsserts disabler;
   // Allow throttling to make sure no painting paths (e.g.,
   // ContentLayerDelegate::paintContents) try to paint throttled content.
   DocumentLifecycle::AllowThrottlingScope allowThrottling(
-      m_owningLayer.layoutObject()->document().lifecycle());
+      m_owningLayer.layoutObject().document().lifecycle());
 #if DCHECK_IS_ON()
   // FIXME: once the state machine is ready, this can be removed and we can
   // refer to that instead.
-  if (Page* page = layoutObject()->frame()->page())
+  if (Page* page = layoutObject().frame()->page())
     page->setIsPainting(true);
 #endif
 
   TRACE_EVENT1(
       "devtools.timeline,rail", "Paint", "data",
-      InspectorPaintEvent::data(m_owningLayer.layoutObject(),
+      InspectorPaintEvent::data(&m_owningLayer.layoutObject(),
                                 LayoutRect(interestRect), graphicsLayer));
 
   PaintLayerFlags paintLayerFlags = 0;
   if (graphicsLayerPaintingPhase & GraphicsLayerPaintBackground)
     paintLayerFlags |= PaintLayerPaintingCompositingBackgroundPhase;
   else
     paintLayerFlags |= PaintLayerPaintingSkipRootBackground;
   if (graphicsLayerPaintingPhase & GraphicsLayerPaintForeground)
     paintLayerFlags |= PaintLayerPaintingCompositingForegroundPhase;
   if (graphicsLayerPaintingPhase & GraphicsLayerPaintMask)
@@ skipping 45 matching lines @@
     // compute and cache clipRects.
     doPaintTask(paintInfo, *graphicsLayer, paintLayerFlags, context,
                 interestRect);
   } else if (graphicsLayer == m_squashingLayer.get()) {
     for (size_t i = 0; i < m_squashedLayers.size(); ++i)
       doPaintTask(m_squashedLayers[i], *graphicsLayer, paintLayerFlags, context,
                   interestRect);
   } else if (isScrollableAreaLayer(graphicsLayer)) {
     paintScrollableArea(graphicsLayer, context, interestRect);
   }
-  InspectorInstrumentation::didPaint(m_owningLayer.layoutObject()->frame(),
+  InspectorInstrumentation::didPaint(m_owningLayer.layoutObject().frame(),
                                      graphicsLayer, context,
                                      LayoutRect(interestRect));
 #if DCHECK_IS_ON()
-  if (Page* page = layoutObject()->frame()->page())
+  if (Page* page = layoutObject().frame()->page())
     page->setIsPainting(false);
 #endif
 }
 
 void CompositedLayerMapping::paintScrollableArea(
     const GraphicsLayer* graphicsLayer,
     GraphicsContext& context,
     const IntRect& interestRect) const {
   // Note the composited scrollable area painted here is never associated with a
   // frame. For painting frame ScrollableAreas, see
@@ skipping 41 matching lines @@
          graphicsLayer == layerForScrollCorner();
 }
 
 bool CompositedLayerMapping::isTrackingRasterInvalidations() const {
   GraphicsLayerClient* client = compositor();
   return client ? client->isTrackingRasterInvalidations() : false;
 }
 
 #if DCHECK_IS_ON()
 void CompositedLayerMapping::verifyNotPainting() {
-  ASSERT(!layoutObject()->frame()->page() ||
-         !layoutObject()->frame()->page()->isPainting());
+  DCHECK(!layoutObject().frame()->page() ||
+         !layoutObject().frame()->page()->isPainting());
 }
 #endif
 
 // Only used for performance benchmark testing. Intended to be a
 // sufficiently-unique element id name to allow picking out the target element
 // for invalidation.
 static const char* kTestPaintInvalidationTargetName =
     "blinkPaintInvalidationTarget";
 
 void CompositedLayerMapping::invalidateTargetElementForTesting() {
   // The below is an artificial construct formed intentionally to focus a
   // microbenchmark on the cost of paint with a partial invalidation.
   Element* targetElement =
-      m_owningLayer.layoutObject()->document().getElementById(
+      m_owningLayer.layoutObject().document().getElementById(
           AtomicString(kTestPaintInvalidationTargetName));
   // TODO(wkorman): If we don't find the expected target element, we could
   // consider walking to the first leaf node so that the partial-invalidation
   // benchmark mode still provides some value when running on generic pages.
   if (!targetElement)
     return;
   LayoutObject* targetObject = targetElement->layoutObject();
   if (!targetObject)
     return;
   targetObject->enclosingLayer()->setNeedsRepaint();
@@ skipping 155 matching lines @@
   } else if (graphicsLayer == m_decorationOutlineLayer.get()) {
     name = "Decoration Layer";
   } else {
     ASSERT_NOT_REACHED();
   }
 
   return name;
 }
 
 }  // namespace blink